mesurer-solid 0.2.1 → 0.2.2-beta.1

package/codex/codex-bridge.mjs

@@ -0,0 +1,2649 @@
+#!/usr/bin/env node
+
+import { spawn } from "node:child_process";
+import { createHash, randomUUID } from "node:crypto";
+import { createServer } from "node:http";
+import { mkdir, readFile, rename, stat, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { parseArgs } from "node:util";
+
+const DEFAULT_PORT = 47365;
+
+const DEFAULT_BRIDGE = `http://127.0.0.1:${DEFAULT_PORT}`;
+
+const BRIDGE_NAME = "mesurer-codex";
+
+const BRIDGE_PROTOCOL_VERSION = 2;
+
+const BRIDGE_CAPABILITIES = Object.freeze([
+  "thread-discovery-v1",
+  "durable-queue-v1",
+  "history-recovery-v2",
+  "client-message-correlation-v1",
+  "idle-safe-shutdown-v1",
+  "nonterminal-retention-v1",
+  "instance-binding-v1",
+]);
+
+const BRIDGE_SOURCE_HASH = createHash("sha256")
+  .update(await readFile(new URL(import.meta.url)))
+  .digest("hex");
+
+const BRIDGE_INSTANCE_ID = randomUUID();
+
+const BRIDGE_IDENTITY = Object.freeze({
+  name: BRIDGE_NAME,
+  protocol: BRIDGE_PROTOCOL_VERSION,
+  capabilities: BRIDGE_CAPABILITIES,
+  sourceHash: BRIDGE_SOURCE_HASH,
+  instanceId: BRIDGE_INSTANCE_ID,
+  pid: process.pid,
+  canShutdown: true,
+});
+
+const MAX_MESSAGE_BYTES = 64 * 1024;
+
+const CODEX_TIMEOUT_MS = 30_000;
+
+const APP_SERVER_TIMEOUT_MS = 5_000;
+
+const DAEMON_RESUME_TIMEOUT_MS = 10_000;
+
+const DAEMON_START_TIMEOUT_MS = 15_000;
+
+const DELIVERY_STATE_VERSION = 1;
+
+const MAX_DISCOVERED_THREADS = 10;
+
+const MAX_DELIVERIES = 100;
+
+const TERMINAL_DELIVERY_TTL_MS = 10 * 60_000;
+
+const DESKTOP_LIFECYCLE_POLL_MS = 1_000;
+
+const DESKTOP_INTERRUPTED_RECONCILE_WINDOW_MS = 2 * 60_000;
+
+const DESKTOP_TURN_HISTORY_LIMIT = 10;
+
+const DELIVERY_TURN_START_SKEW_MS = 60_000;
+
+const LAST_OWNER_SHUTDOWN_DELAY_MS = 250;
+
+const IDLE_PENDING_RECHECK_MS = 5_000;
+
+const configuredOwnerHealthPollMs = Number(process.env.MESURER_CODEX_OWNER_POLL_MS);
+
+const OWNER_HEALTH_POLL_MS = Number.isFinite(configuredOwnerHealthPollMs) && configuredOwnerHealthPollMs > 0
+  ? Math.max(50, configuredOwnerHealthPollMs)
+  : 5_000;
+
+const OWNED_CHILD_SHUTDOWN_GRACE_MS = 250;
+
+const usage = `Usage:
+  mesurer-codex [--thread <session-id-or-name>] [options]
+  mesurer-codex --register-current [--bridge <url>]
+  mesurer-codex --register <session-id-or-name> [--bridge <url>]
+
+Server options:
+  --thread <value>    Initial Codex session UUID or exact session name.
+                      Defaults to CODEX_THREAD_ID when launched by Codex.
+  --cwd <path>        Project directory used to scope recent-thread discovery.
+                      Defaults to the current working directory.
+  --port <number>     Loopback port (default: ${DEFAULT_PORT}; use 0 for any free port)
+  --origin <origin>   Additional allowed browser Origin. Repeatable.
+  --codex <path>      Codex executable (default: CODEX_BIN or codex)
+  --once              Exit after one successful queued message
+
+Thread registration:
+  --register-current  Register CODEX_THREAD_ID with a running bridge and make it active.
+  --register <value>  Register a specific existing/newly-created Codex thread and make it active.
+  --bridge <url>      Running bridge URL for registration (default: ${DEFAULT_BRIDGE})
+
+Other:
+  --help              Show this help
+
+Loopback browser origins such as http://localhost:* and http://127.0.0.1:* are allowed by default.
+For file:// or Electron pages, pass --origin null explicitly.
+Browser pages may send to locally registered threads and same-project recent threads returned by Codex app-server discovery.
+`;
+
+const { values } = parseArgs({
+  options: {
+    thread: { type: "string" },
+    cwd: { type: "string" },
+    port: { type: "string", default: String(DEFAULT_PORT) },
+    origin: { type: "string", multiple: true },
+    codex: { type: "string" },
+    once: { type: "boolean", default: false },
+    register: { type: "string" },
+    "register-current": { type: "boolean", default: false },
+    bridge: { type: "string", default: DEFAULT_BRIDGE },
+    help: { type: "boolean", default: false },
+  },
+  allowPositionals: false,
+  strict: true,
+});
+
+if (values.help) {
+  process.stdout.write(usage);
+  process.exit(0);
+}
+
+const normalizeThread = (value) => value?.trim() || null;
+
+const normalizeCwd = (value) => value?.trim() || null;
+
+const envThread = normalizeThread(process.env.CODEX_THREAD_ID);
+
+const requestedRegistration = normalizeThread(values.register);
+
+const registerCurrent = values["register-current"];
+
+if (requestedRegistration && registerCurrent) {
+  process.stderr.write("Use either --register or --register-current, not both.\n");
+  process.exit(2);
+}
+
+const registrationThread = registerCurrent ? envThread : requestedRegistration;
+
+if (registerCurrent && !registrationThread) {
+  process.stderr.write("--register-current requires CODEX_THREAD_ID. Run it from a Codex shell/tool command or use --register <thread>.\n");
+  process.exit(2);
+}
+
+if (registrationThread) {
+  const bridge = values.bridge?.trim() || DEFAULT_BRIDGE;
+  const cwd = normalizeCwd(values.cwd) ?? process.cwd();
+  let response;
+
+  try {
+    response = await fetch(new URL("threads/register", bridge.endsWith("/") ? bridge : `${bridge}/`), {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ thread: registrationThread, cwd }),
+    });
+  } catch (cause) {
+    const error = cause instanceof Error ? cause.message : String(cause);
+    process.stderr.write(`Could not reach Mesurer Codex bridge at ${bridge}: ${error}\n`);
+    process.exit(1);
+  }
+
+  const text = await response.text();
+  let payload = {};
+
+  if (text) {
+    try {
+      payload = JSON.parse(text);
+    } catch {
+      payload = { error: text };
+    }
+  }
+
+  if (!response.ok || payload.ok === false) {
+    process.stderr.write(`${payload.error || `Mesurer Codex bridge returned HTTP ${response.status}.`}\n`);
+    process.exit(1);
+  }
+
+  console.log(`Registered Codex thread: ${registrationThread}`);
+  console.log(`BRIDGE_THREAD=${registrationThread}`);
+  process.exit(0);
+}
+
+const parsedPort = Number(values.port);
+
+if (!Number.isInteger(parsedPort) || parsedPort < 0 || parsedPort > 65_535) {
+  process.stderr.write(`Invalid --port: ${values.port}\n`);
+  process.exit(2);
+}
+
+const initialThread = normalizeThread(values.thread) ?? envThread;
+
+const initialCwd = initialThread ? (normalizeCwd(values.cwd) ?? process.cwd()) : null;
+
+const initialAppToolsPipe = normalizeThread(process.env.CODEX_APP_TOOLS_PIPE_PATH);
+
+const initialCodexHome = normalizeCwd(process.env.CODEX_HOME);
+
+const codexBin = values.codex?.trim() || process.env.CODEX_BIN?.trim() || "codex";
+
+const normalizeConfiguredOrigin = (value) => {
+  const origin = value?.trim();
+
+  if (!origin) return null;
+
+  if (origin === "null") return "null";
+
+  try {
+    const url = new URL(origin);
+
+    return url.protocol === "http:" || url.protocol === "https:" ? url.origin : null;
+  } catch {
+    return null;
+  }
+};
+
+const additionalOrigins = new Set();
+
+for (const value of values.origin ?? []) {
+  const origin = normalizeConfiguredOrigin(value);
+
+  if (!origin) {
+    process.stderr.write(`Invalid --origin: ${value}\n`);
+    process.exit(2);
+  }
+
+  additionalOrigins.add(origin);
+}
+
+const registeredThreads = new Map();
+
+const discoveredThreads = new Map();
+
+const deliveries = new Map();
+
+const terminalTurnEvents = new Map();
+
+const desktopDispatchTimers = new Map();
+
+const desktopLifecycleChecks = new Map();
+
+const desktopLifecycleTimers = new Map();
+
+const ownedChildren = new Set();
+
+const clearDesktopLifecycleTimer = (deliveryId) => {
+  const timer = desktopLifecycleTimers.get(deliveryId);
+
+  if (timer) clearTimeout(timer);
+  desktopLifecycleTimers.delete(deliveryId);
+};
+
+let activeThread = null;
+
+let activeCwd = null;
+
+let idleShutdownTimer = null;
+
+let ownerHealthTimer = null;
+
+let server = null;
+
+let shutdownStarted = false;
+
+const spawnOwned = (...args) => {
+  const child = spawn(...args);
+  ownedChildren.add(child);
+
+  const release = () => ownedChildren.delete(child);
+  child.once("close", release);
+  child.once("error", release);
+
+  return child;
+};
+
+const cancelIdleShutdown = () => {
+  if (!idleShutdownTimer) return;
+  clearTimeout(idleShutdownTimer);
+  idleShutdownTimer = null;
+};
+
+const deliveryNeedsDesktopLifecycleCheck = (delivery) => {
+  if (delivery.transport !== "desktop-app" || delivery.dispatch !== "desktop-opened") {
+    return false;
+  }
+
+  if (delivery.status === "queued" || delivery.status === "working") return true;
+
+  return delivery.status === "interrupted"
+    && Date.now() - delivery.updatedAt < DESKTOP_INTERRUPTED_RECONCILE_WINDOW_MS;
+};
+
+const nonTerminalDeliveryCount = () =>
+  [...deliveries.values()].filter((delivery) =>
+    delivery.status === "queued" || delivery.status === "working").length;
+
+const reconcilingDeliveryCount = () =>
+  [...deliveries.values()].filter((delivery) =>
+    deliveryNeedsDesktopLifecycleCheck(delivery)).length;
+
+const retainedDeliveryCount = () =>
+  [...deliveries.values()].filter((delivery) =>
+    delivery.status === "queued"
+    || delivery.status === "working"
+    || deliveryNeedsDesktopLifecycleCheck(delivery)).length;
+
+const bridgeCanShutdown = () =>
+  registeredThreads.size === 0 && retainedDeliveryCount() === 0;
+
+const bridgeState = () => ({
+  registeredThreads: registeredThreads.size,
+  deliveries: deliveries.size,
+  nonTerminalDeliveries: nonTerminalDeliveryCount(),
+  reconcilingDeliveries: reconcilingDeliveryCount(),
+  idle: bridgeCanShutdown(),
+});
+
+const ownerAnchorExists = async (path) => {
+  try {
+    await stat(path);
+
+    return true;
+  } catch (cause) {
+    return cause?.code !== "ENOENT" && cause?.code !== "ENOTDIR";
+  }
+};
+
+const refreshOwnerHealthMonitor = () => {
+  const needsMonitor = process.platform !== "win32"
+    && [...registeredThreads.values()].some((record) => record.appToolsPipe);
+
+  if (!needsMonitor) {
+    if (ownerHealthTimer) clearInterval(ownerHealthTimer);
+    ownerHealthTimer = null;
+
+    return;
+  }
+
+  if (ownerHealthTimer) return;
+
+  ownerHealthTimer = setInterval(() => {
+    void pruneMissingDesktopOwners();
+  }, OWNER_HEALTH_POLL_MS);
+  ownerHealthTimer.unref?.();
+};
+
+const scheduleIdleShutdown = () => {
+  if (shutdownStarted || registeredThreads.size > 0 || idleShutdownTimer) return;
+
+  const delay = bridgeCanShutdown()
+    ? LAST_OWNER_SHUTDOWN_DELAY_MS
+    : IDLE_PENDING_RECHECK_MS;
+
+  idleShutdownTimer = setTimeout(() => {
+    idleShutdownTimer = null;
+    pruneDeliveries();
+
+    if (bridgeCanShutdown()) {
+      void shutdownBridge();
+
+      return;
+    }
+
+    if (registeredThreads.size === 0) scheduleIdleShutdown();
+  }, delay);
+  idleShutdownTimer.unref?.();
+};
+
+const unregisterThread = (thread) => {
+  const record = registeredThreads.get(thread);
+
+  if (!record) return false;
+
+  registeredThreads.delete(thread);
+
+  const dispatchTimer = desktopDispatchTimers.get(thread);
+
+  if (dispatchTimer) {
+    clearTimeout(dispatchTimer);
+    desktopDispatchTimers.delete(thread);
+  }
+
+  if (activeThread === thread) {
+    const next = [...registeredThreads.values()]
+      .sort((left, right) => right.seenAt - left.seenAt)[0] ?? null;
+
+    activeThread = next?.id ?? null;
+    activeCwd = next?.cwd ?? null;
+  }
+
+  refreshOwnerHealthMonitor();
+  scheduleIdleShutdown();
+
+  return true;
+};
+
+async function pruneMissingDesktopOwners() {
+  for (const record of registeredThreads.values()) {
+    if (!record.appToolsPipe) continue;
+
+    if (!(await ownerAnchorExists(record.appToolsPipe))) {
+      unregisterThread(record.id);
+    }
+  }
+}
+
+const registerThread = (thread, cwd, registration = {}) => {
+  cancelIdleShutdown();
+
+  const previous = registeredThreads.get(thread);
+  const nextCwd = normalizeCwd(cwd) ?? previous?.cwd ?? null;
+  const appToolsPipe = normalizeThread(registration.appToolsPipe) ?? previous?.appToolsPipe ?? null;
+  const codexHome = normalizeCwd(registration.codexHome) ?? previous?.codexHome ?? null;
+  registeredThreads.set(thread, {
+    id: thread,
+    cwd: nextCwd,
+    appToolsPipe,
+    codexHome,
+    seenAt: Date.now(),
+  });
+  activeThread = thread;
+
+  if (nextCwd) activeCwd = nextCwd;
+
+  refreshOwnerHealthMonitor();
+};
+
+if (initialThread) {
+  registerThread(initialThread, initialCwd, {
+    appToolsPipe: initialAppToolsPipe,
+    codexHome: initialCodexHome,
+  });
+}
+
+const isLoopbackOrigin = (origin) => {
+  try {
+    const url = new URL(origin);
+
+    return url.hostname === "localhost"
+      || url.hostname === "127.0.0.1"
+      || url.hostname === "::1"
+      || url.hostname === "[::1]";
+  } catch {
+    return false;
+  }
+};
+
+const corsOrigin = (origin) => {
+  if (!origin) return null;
+
+  if (origin === "null") return "null";
+
+  try {
+    const url = new URL(origin);
+
+    return url.protocol === "http:" || url.protocol === "https:" ? url.origin : null;
+  } catch {
+    return null;
+  }
+};
+
+const originAllowed = (origin) => {
+  if (!origin) return true;
+  const normalized = corsOrigin(origin);
+
+  if (!normalized) return false;
+
+  return additionalOrigins.has(normalized) || isLoopbackOrigin(normalized);
+};
+
+const corsHeaders = (origin, exposeDenied = false) => {
+  const safeOrigin = corsOrigin(origin);
+
+  if (!safeOrigin || (!exposeDenied && !originAllowed(safeOrigin))) return {};
+
+  return {
+    "Access-Control-Allow-Origin": safeOrigin,
+    "Access-Control-Allow-Headers": "Content-Type, X-Mesurer-Bridge-Instance",
+    "Access-Control-Allow-Methods": "GET, POST, OPTIONS",
+    "Vary": "Origin",
+  };
+};
+
+const writeJson = (response, status, payload, origin, exposeDenied = false) => {
+  response.writeHead(status, {
+    "Content-Type": "application/json; charset=utf-8",
+    "Cache-Control": "no-store",
+    ...corsHeaders(origin, exposeDenied),
+  });
+  response.end(`${JSON.stringify(payload)}\n`);
+};
+
+const readJsonBody = async (request) => {
+  const chunks = [];
+  let bytes = 0;
+
+  for await (const chunk of request) {
+    bytes += chunk.length;
+
+    if (bytes > MAX_MESSAGE_BYTES) throw new Error("Mesurer Codex message is too large.");
+    chunks.push(chunk);
+  }
+
+  const text = Buffer.concat(chunks).toString("utf8");
+
+  if (!text) return {};
+
+  return JSON.parse(text);
+};
+
+const defaultCodexHome = normalizeCwd(process.env.CODEX_HOME) ?? join(homedir(), ".codex");
+
+const deliveryStatePath = join(defaultCodexHome, "mesurer", "codex-deliveries.json");
+
+let deliveryStateWrite = Promise.resolve();
+
+const persistedDelivery = (delivery) => ({
+  id: delivery.id,
+  thread: delivery.thread,
+  message: delivery.message,
+  messageHash: delivery.messageHash,
+  transport: delivery.transport,
+  status: delivery.status,
+  turnId: delivery.turnId,
+  queuedSubmissionId: delivery.queuedSubmissionId,
+  clientUserMessageId: delivery.clientUserMessageId,
+  dispatch: delivery.dispatch,
+  dispatchError: delivery.dispatchError,
+  createdAt: delivery.createdAt,
+  updatedAt: delivery.updatedAt,
+});
+
+const persistDeliveryState = () => {
+  const persistedDeliveries = [];
+
+  for (const delivery of deliveries.values()) {
+    if (delivery.transport === "desktop-app") {
+      persistedDeliveries.push(persistedDelivery(delivery));
+    }
+  }
+
+  const state = {
+    version: DELIVERY_STATE_VERSION,
+    deliveries: persistedDeliveries,
+  };
+
+  deliveryStateWrite = deliveryStateWrite.then(async () => {
+    const directory = join(defaultCodexHome, "mesurer");
+    await mkdir(directory, { recursive: true });
+    const temporaryPath = `${deliveryStatePath}.${process.pid}.tmp`;
+    await writeFile(temporaryPath, `${JSON.stringify(state)}\n`, "utf8");
+    await rename(temporaryPath, deliveryStatePath);
+  });
+
+  return deliveryStateWrite;
+};
+
+const persistDeliveryStateSoon = () => {
+  void persistDeliveryState().catch((cause) => {
+    const error = cause instanceof Error ? cause.message : String(cause);
+    process.stderr.write(`Mesurer Codex bridge could not persist delivery state: ${error}\n`);
+  });
+};
+
+const loadDeliveryState = async () => {
+  let text;
+
+  try {
+    text = await readFile(deliveryStatePath, "utf8");
+  } catch (cause) {
+    if (cause?.code === "ENOENT") return;
+    throw cause;
+  }
+
+  const state = JSON.parse(text);
+
+  if (state?.version !== DELIVERY_STATE_VERSION || !Array.isArray(state.deliveries)) return;
+  const now = Date.now();
+
+  for (const value of state.deliveries) {
+    const id = normalizeThread(value?.id);
+    const thread = normalizeThread(value?.thread);
+    const message = value?.message == null ? "" : String(value.message);
+    const transport = value?.transport === "desktop-app" ? "desktop-app" : "codex-queue";
+    const status = value?.status;
+    const createdAt = Number(value?.createdAt);
+    const updatedAt = Number(value?.updatedAt);
+
+    if (!id || !thread || !message.trim()) continue;
+
+    if (!["queued", "working", "completed", "interrupted"].includes(status)) continue;
+
+    if (!Number.isFinite(createdAt) || !Number.isFinite(updatedAt)) continue;
+
+    if ((status === "completed" || status === "interrupted")
+      && now - updatedAt > TERMINAL_DELIVERY_TTL_MS) {
+      continue;
+    }
+
+    deliveries.set(id, {
+      id,
+      thread,
+      message,
+      messageHash: normalizeThread(value?.messageHash) ?? createHash("sha256").update(message).digest("hex"),
+      transport,
+      status,
+      turnId: normalizeThread(value?.turnId),
+      queuedSubmissionId: normalizeThread(value?.queuedSubmissionId),
+      clientUserMessageId: normalizeThread(value?.clientUserMessageId),
+      dispatch: normalizeThread(value?.dispatch) ?? "persisted",
+      dispatchError: normalizeThread(value?.dispatchError),
+      createdAt,
+      updatedAt,
+    });
+  }
+};
+
+const queuedSubmissionFromOutput = (output, thread) => {
+  const match = output.match(/Queued message (\S+) for thread (\S+)\.?/);
+
+  if (!match) return null;
+  const queuedThread = match[2].replace(/\.$/, "");
+
+  return queuedThread === thread ? match[1] : null;
+};
+
+const codexControlSocketPath = () => {
+  const codexHome = process.env.CODEX_HOME?.trim() || join(homedir(), ".codex");
+
+  return join(codexHome, "app-server-control", "app-server-control.sock");
+};
+
+const runCodexDaemonStart = () => new Promise((resolve, reject) => {
+  const child = spawnOwned(codexBin, ["app-server", "daemon", "start"], {
+    env: process.env,
+    shell: false,
+    stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: true,
+  });
+
+  let stdout = "";
+  let stderr = "";
+  let settled = false;
+  let timeout;
+
+  const finish = (error, output) => {
+    if (settled) return;
+    settled = true;
+
+    if (timeout) clearTimeout(timeout);
+
+    if (error) reject(error);
+    else resolve(output);
+  };
+
+  child.stdout.on("data", (chunk) => { stdout += chunk.toString(); });
+  child.stderr.on("data", (chunk) => { stderr += chunk.toString(); });
+  child.on("error", (error) => finish(error));
+  child.on("close", (code, signal) => {
+    if (code === 0) {
+      finish(null, stdout.trim());
+
+      return;
+    }
+
+    const detail = stderr.trim() || stdout.trim() || `exit code ${code ?? "unknown"}${signal ? ` (${signal})` : ""}`;
+    finish(new Error(`codex app-server daemon start failed: ${detail}`));
+  });
+
+  timeout = setTimeout(() => {
+    child.kill("SIGTERM");
+    finish(new Error(`codex app-server daemon start timed out after ${DAEMON_START_TIMEOUT_MS}ms.`));
+  }, DAEMON_START_TIMEOUT_MS);
+});
+
+const missingDaemonSocket = (cause) => {
+  if (!(cause instanceof Error)) return false;
+
+  return cause.message.includes("No such file or directory")
+    || cause.message.includes("ENOENT")
+    || cause.message.includes("os error 2");
+};
+
+const resumeColdCodexThreadViaDaemon = (thread) => new Promise((resolve, reject) => {
+  if (process.platform === "win32") {
+    resolve({ action: "unsupported", threadStatus: null });
+
+    return;
+  }
+
+  const child = spawnOwned(codexBin, ["stdio-to-uds", codexControlSocketPath()], {
+    env: process.env,
+    shell: false,
+    stdio: ["pipe", "pipe", "pipe"],
+    windowsHide: true,
+  });
+
+  let stdoutBuffer = "";
+  let stderr = "";
+  let settled = false;
+  let timeout;
+
+  const finish = (error, result) => {
+    if (settled) return;
+    settled = true;
+
+    if (timeout) clearTimeout(timeout);
+
+    if (child.exitCode === null) child.kill("SIGTERM");
+
+    if (error) reject(error);
+    else resolve(result);
+  };
+
+  const send = (message) => {
+    child.stdin.write(`${JSON.stringify(message)}\n`);
+  };
+
+  const handleMessage = (message) => {
+    if (message?.id === "mesurer-daemon-init") {
+      if (message.error) {
+        finish(new Error(message.error.message || "Codex daemon initialize failed."));
+
+        return;
+      }
+
+      send({ method: "initialized" });
+      send({
+        id: "mesurer-thread-read",
+        method: "thread/read",
+        params: {
+          threadId: thread,
+          includeTurns: false,
+        },
+      });
+
+      return;
+    }
+
+    if (message?.id === "mesurer-thread-read") {
+      if (message.error) {
+        finish(new Error(message.error.message || "Codex daemon thread/read failed."));
+
+        return;
+      }
+
+      const threadStatus = message.result?.thread?.status?.type ?? null;
+
+      if (threadStatus !== "notLoaded") {
+        finish(null, { action: "already-loaded", threadStatus });
+
+        return;
+      }
+
+      send({
+        id: "mesurer-thread-resume",
+        method: "thread/resume",
+        params: { threadId: thread },
+      });
+
+      return;
+    }
+
+    if (message?.id === "mesurer-thread-resume") {
+      if (message.error) {
+        finish(new Error(message.error.message || "Codex daemon thread/resume failed."));
+
+        return;
+      }
+
+      finish(null, { action: "resumed", threadStatus: "notLoaded" });
+    }
+  };
+
+  child.stdout.on("data", (chunk) => {
+    stdoutBuffer += chunk.toString();
+
+    while (true) {
+      const newline = stdoutBuffer.indexOf("\n");
+
+      if (newline < 0) break;
+      const line = stdoutBuffer.slice(0, newline).trim();
+      stdoutBuffer = stdoutBuffer.slice(newline + 1);
+
+      if (!line) continue;
+
+      try {
+        handleMessage(JSON.parse(line));
+      } catch {
+        // The relay carries app-server JSONL. Ignore unrelated stdout defensively.
+      }
+    }
+  });
+  child.stderr.on("data", (chunk) => {
+    stderr = `${stderr}${chunk.toString()}`.slice(-8_192);
+  });
+  child.on("error", (error) => finish(error));
+  child.on("close", (code, signal) => {
+    if (settled) return;
+    const detail = stderr.trim() || `exit code ${code ?? "unknown"}${signal ? ` (${signal})` : ""}`;
+    finish(new Error(`Codex daemon relay exited before thread resume check completed: ${detail}`));
+  });
+
+  timeout = setTimeout(() => {
+    child.kill("SIGTERM");
+    finish(new Error(`Codex daemon resume check timed out after ${DAEMON_RESUME_TIMEOUT_MS}ms.`));
+  }, DAEMON_RESUME_TIMEOUT_MS);
+
+  send({
+    id: "mesurer-daemon-init",
+    method: "initialize",
+    params: {
+      clientInfo: {
+        name: "mesurer-solid",
+        title: "Mesurer Solid",
+        version: "1",
+      },
+      capabilities: {
+        experimentalApi: true,
+      },
+    },
+  });
+});
+
+const resumeColdCodexThread = async (thread) => {
+  try {
+    return await resumeColdCodexThreadViaDaemon(thread);
+  } catch (cause) {
+    if (!missingDaemonSocket(cause)) throw cause;
+    await runCodexDaemonStart();
+
+    return resumeColdCodexThreadViaDaemon(thread);
+  }
+};
+
+const runCodexQueue = (thread, message) => new Promise((resolve, reject) => {
+  const child = spawnOwned(codexBin, ["queue", "--thread", thread, "--message", message], {
+    env: process.env,
+    shell: false,
+    stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: true,
+  });
+
+  let stdout = "";
+  let stderr = "";
+  let settled = false;
+  let timeout;
+
+  const finish = (error, output) => {
+    if (settled) return;
+    settled = true;
+
+    if (timeout) clearTimeout(timeout);
+
+    if (error) reject(error);
+    else resolve(output);
+  };
+
+  child.stdout.on("data", (chunk) => { stdout += chunk.toString(); });
+  child.stderr.on("data", (chunk) => { stderr += chunk.toString(); });
+  child.on("error", (error) => finish(error));
+  child.on("close", (code, signal) => {
+    if (code === 0) {
+      finish(null, stdout.trim());
+
+      return;
+    }
+
+    const detail = stderr.trim() || stdout.trim() || `exit code ${code ?? "unknown"}${signal ? ` (${signal})` : ""}`;
+    finish(new Error(`codex queue failed: ${detail}`));
+  });
+
+  timeout = setTimeout(() => {
+    child.kill("SIGTERM");
+    finish(new Error(`codex queue timed out after ${CODEX_TIMEOUT_MS}ms.`));
+  }, CODEX_TIMEOUT_MS);
+});
+
+const runCodexThreadList = (cwd, limit) => new Promise((resolve, reject) => {
+  const child = spawnOwned(codexBin, ["app-server", "--listen", "stdio://"], {
+    env: process.env,
+    shell: false,
+    stdio: ["pipe", "pipe", "pipe"],
+    windowsHide: true,
+  });
+
+  let stdoutBuffer = "";
+  let stderr = "";
+  let settled = false;
+  let timeout;
+
+  const finish = (error, result) => {
+    if (settled) return;
+    settled = true;
+
+    if (timeout) clearTimeout(timeout);
+
+    if (child.exitCode === null) child.kill("SIGTERM");
+
+    if (error) reject(error);
+    else resolve(result);
+  };
+
+  const send = (message) => {
+    child.stdin.write(`${JSON.stringify(message)}\n`);
+  };
+
+  const handleMessage = (message) => {
+    if (message?.id === "mesurer-init") {
+      if (message.error) {
+        finish(new Error(message.error.message || "Codex app-server initialize failed."));
+
+        return;
+      }
+
+      send({ method: "initialized" });
+      send({
+        id: "mesurer-thread-list",
+        method: "thread/list",
+        params: {
+          limit,
+          sortKey: "recency_at",
+          sortDirection: "desc",
+          cwd,
+        },
+      });
+
+      return;
+    }
+
+    if (message?.id === "mesurer-thread-list") {
+      if (message.error) {
+        finish(new Error(message.error.message || "Codex app-server thread/list failed."));
+
+        return;
+      }
+
+      finish(null, message.result ?? {});
+    }
+  };
+
+  child.stdout.on("data", (chunk) => {
+    stdoutBuffer += chunk.toString();
+
+    while (true) {
+      const newline = stdoutBuffer.indexOf("\n");
+
+      if (newline < 0) break;
+      const line = stdoutBuffer.slice(0, newline).trim();
+      stdoutBuffer = stdoutBuffer.slice(newline + 1);
+
+      if (!line) continue;
+
+      try {
+        handleMessage(JSON.parse(line));
+      } catch {
+        // App-server protocol is JSONL; ignore unrelated stdout defensively.
+      }
+    }
+  });
+  child.stderr.on("data", (chunk) => {
+    stderr = `${stderr}${chunk.toString()}`.slice(-8_192);
+  });
+  child.on("error", (error) => finish(error));
+  child.on("close", (code, signal) => {
+    if (settled) return;
+    const detail = stderr.trim() || `exit code ${code ?? "unknown"}${signal ? ` (${signal})` : ""}`;
+    finish(new Error(`Codex app-server exited before thread/list completed: ${detail}`));
+  });
+
+  timeout = setTimeout(() => {
+    child.kill("SIGTERM");
+    finish(new Error(`Codex app-server thread/list timed out after ${APP_SERVER_TIMEOUT_MS}ms.`));
+  }, APP_SERVER_TIMEOUT_MS);
+
+  send({
+    id: "mesurer-init",
+    method: "initialize",
+    params: {
+      clientInfo: {
+        name: "mesurer-solid",
+        title: "Mesurer Solid",
+        version: "1",
+      },
+      capabilities: {
+        experimentalApi: true,
+      },
+    },
+  });
+});
+
+const runCodexQueueLookup = (thread, queuedSubmissionId = null) => new Promise((resolve, reject) => {
+  const child = spawnOwned(codexBin, ["app-server", "--listen", "stdio://"], {
+    env: process.env,
+    shell: false,
+    stdio: ["pipe", "pipe", "pipe"],
+    windowsHide: true,
+  });
+
+  let stdoutBuffer = "";
+  let stderr = "";
+  let settled = false;
+  let timeout;
+  let cursor = null;
+  let page = 0;
+
+  const finish = (error, result) => {
+    if (settled) return;
+    settled = true;
+
+    if (timeout) clearTimeout(timeout);
+
+    if (child.exitCode === null) child.kill("SIGTERM");
+
+    if (error) reject(error);
+    else resolve(result);
+  };
+
+  const send = (message) => {
+    child.stdin.write(`${JSON.stringify(message)}\n`);
+  };
+
+  const requestPage = () => {
+    page += 1;
+
+    const params = {
+      threadId: thread,
+      limit: queuedSubmissionId ? 100 : 2,
+    };
+
+    if (cursor) params.cursor = cursor;
+    send({
+      id: `mesurer-queue-list-${page}`,
+      method: "thread/queue/list",
+      params,
+    });
+  };
+
+  const handleMessage = (message) => {
+    if (message?.id === "mesurer-queue-init") {
+      if (message.error) {
+        finish(new Error(message.error.message || "Codex app-server initialize failed."));
+
+        return;
+      }
+
+      send({ method: "initialized" });
+      requestPage();
+
+      return;
+    }
+
+    const messageId = message?.id == null ? "" : String(message.id);
+
+    if (!messageId.startsWith("mesurer-queue-list-")) return;
+
+    if (message.error) {
+      finish(new Error(message.error.message || "Codex app-server thread/queue/list failed."));
+
+      return;
+    }
+
+    const data = Array.isArray(message.result?.data) ? message.result.data : [];
+    const nextCursor = normalizeThread(message.result?.nextCursor);
+
+    if (queuedSubmissionId) {
+      const submission = data.find((candidate) => candidate?.id === queuedSubmissionId);
+
+      if (submission) {
+        finish(null, { submission, ambiguous: false });
+
+        return;
+      }
+
+      if (nextCursor) {
+        cursor = nextCursor;
+        requestPage();
+
+        return;
+      }
+
+      finish(null, { submission: null, ambiguous: false });
+
+      return;
+    }
+
+    if (data.length === 1 && !nextCursor) {
+      finish(null, { submission: data[0], ambiguous: false });
+
+      return;
+    }
+
+    finish(null, {
+      submission: null,
+      ambiguous: data.length > 1 || Boolean(nextCursor),
+    });
+  };
+
+  child.stdout.on("data", (chunk) => {
+    stdoutBuffer += chunk.toString();
+
+    while (true) {
+      const newline = stdoutBuffer.indexOf("\n");
+
+      if (newline < 0) break;
+      const line = stdoutBuffer.slice(0, newline).trim();
+      stdoutBuffer = stdoutBuffer.slice(newline + 1);
+
+      if (!line) continue;
+
+      try {
+        handleMessage(JSON.parse(line));
+      } catch {
+        // App-server protocol is JSONL; ignore unrelated stdout defensively.
+      }
+    }
+  });
+  child.stderr.on("data", (chunk) => {
+    stderr = `${stderr}${chunk.toString()}`.slice(-8_192);
+  });
+  child.on("error", (error) => finish(error));
+  child.on("close", (code, signal) => {
+    if (settled) return;
+    const detail = stderr.trim() || `exit code ${code ?? "unknown"}${signal ? ` (${signal})` : ""}`;
+    finish(new Error(`Codex app-server exited before thread/queue/list completed: ${detail}`));
+  });
+
+  timeout = setTimeout(() => {
+    child.kill("SIGTERM");
+    finish(new Error(`Codex app-server thread/queue/list timed out after ${APP_SERVER_TIMEOUT_MS}ms.`));
+  }, APP_SERVER_TIMEOUT_MS);
+
+  send({
+    id: "mesurer-queue-init",
+    method: "initialize",
+    params: {
+      clientInfo: {
+        name: "mesurer-solid",
+        title: "Mesurer Solid",
+        version: "1",
+      },
+      capabilities: {
+        experimentalApi: true,
+      },
+    },
+  });
+});
+
+const queuedSubmissionMessage = (submission) => {
+  if (!Array.isArray(submission?.input) || submission.input.length !== 1) return null;
+  const input = submission.input[0];
+  const text = String(input?.text ?? "");
+
+  return input?.type === "text" && text.trim() ? text : null;
+};
+
+const runCodexTurnHistory = (thread) => new Promise((resolve, reject) => {
+  const child = spawnOwned(codexBin, ["app-server", "--listen", "stdio://"], {
+    env: process.env,
+    shell: false,
+    stdio: ["pipe", "pipe", "pipe"],
+    windowsHide: true,
+  });
+
+  let stdoutBuffer = "";
+  let stderr = "";
+  let settled = false;
+  let timeout;
+
+  const finish = (error, turns) => {
+    if (settled) return;
+    settled = true;
+
+    if (timeout) clearTimeout(timeout);
+
+    if (child.exitCode === null) child.kill("SIGTERM");
+
+    if (error) reject(error);
+    else resolve(turns);
+  };
+
+  const send = (message) => {
+    child.stdin.write(`${JSON.stringify(message)}\n`);
+  };
+
+  const handleMessage = (message) => {
+    if (message?.id === "mesurer-history-init") {
+      if (message.error) {
+        finish(new Error(message.error.message || "Codex app-server initialize failed."));
+
+        return;
+      }
+
+      send({ method: "initialized" });
+      send({
+        id: "mesurer-history-turns",
+        method: "thread/turns/list",
+        params: {
+          threadId: thread,
+          limit: DESKTOP_TURN_HISTORY_LIMIT,
+          sortDirection: "desc",
+          itemsView: "summary",
+        },
+      });
+
+      return;
+    }
+
+    if (message?.id === "mesurer-history-turns") {
+      if (message.error) {
+        send({
+          id: "mesurer-history-read",
+          method: "thread/read",
+          params: {
+            threadId: thread,
+            includeTurns: true,
+          },
+        });
+
+        return;
+      }
+
+      finish(null, Array.isArray(message.result?.data) ? message.result.data : []);
+
+      return;
+    }
+
+    if (message?.id === "mesurer-history-read") {
+      if (message.error) {
+        finish(new Error(message.error.message || "Codex app-server thread history read failed."));
+
+        return;
+      }
+
+      finish(null, Array.isArray(message.result?.thread?.turns) ? message.result.thread.turns : []);
+    }
+  };
+
+  child.stdout.on("data", (chunk) => {
+    stdoutBuffer += chunk.toString();
+
+    while (true) {
+      const newline = stdoutBuffer.indexOf("\n");
+
+      if (newline < 0) break;
+      const line = stdoutBuffer.slice(0, newline).trim();
+      stdoutBuffer = stdoutBuffer.slice(newline + 1);
+
+      if (!line) continue;
+
+      try {
+        handleMessage(JSON.parse(line));
+      } catch {
+        // App-server protocol is JSONL; ignore unrelated stdout defensively.
+      }
+    }
+  });
+  child.stderr.on("data", (chunk) => {
+    stderr = `${stderr}${chunk.toString()}`.slice(-8_192);
+  });
+  child.on("error", (error) => finish(error));
+  child.on("close", (code, signal) => {
+    if (settled) return;
+    const detail = stderr.trim() || `exit code ${code ?? "unknown"}${signal ? ` (${signal})` : ""}`;
+    finish(new Error(`Codex app-server exited before lifecycle history completed: ${detail}`));
+  });
+
+  timeout = setTimeout(() => {
+    child.kill("SIGTERM");
+    finish(new Error(`Codex app-server lifecycle history timed out after ${APP_SERVER_TIMEOUT_MS}ms.`));
+  }, APP_SERVER_TIMEOUT_MS);
+
+  send({
+    id: "mesurer-history-init",
+    method: "initialize",
+    params: {
+      clientInfo: {
+        name: "mesurer-solid",
+        title: "Mesurer Solid",
+        version: "1",
+      },
+      capabilities: {
+        experimentalApi: true,
+      },
+    },
+  });
+});
+
+const openDesktopThread = (thread) => new Promise((resolveOpen, rejectOpen) => {
+  const url = `codex://threads/${thread}`;
+  const override = process.env.MESURER_CODEX_DESKTOP_OPEN_BIN?.trim();
+  let command;
+  let args;
+
+  if (override) {
+    command = override;
+    args = [url];
+  } else if (process.platform === "darwin") {
+    command = "/usr/bin/open";
+    args = [url];
+  } else if (process.platform === "win32") {
+    command = "powershell.exe";
+    const quotedUrl = url.replaceAll("'", "''");
+    args = [
+      "-NoProfile",
+      "-Command",
+      `Start-Process -FilePath '${quotedUrl}'`,
+    ];
+  } else {
+    rejectOpen(new Error(
+      `Codex Desktop thread wake is unsupported on platform ${process.platform}.`,
+    ));
+
+    return;
+  }
+
+  const child = spawnOwned(command, args, {
+    env: process.env,
+    shell: false,
+    stdio: ["ignore", "ignore", "pipe"],
+    windowsHide: true,
+  });
+
+  let stderr = "";
+  let settled = false;
+
+  const timeout = setTimeout(() => {
+    child.kill("SIGTERM");
+
+    if (settled) return;
+    settled = true;
+    rejectOpen(new Error("Codex Desktop thread open timed out."));
+  }, APP_SERVER_TIMEOUT_MS);
+
+  child.stderr.on("data", (chunk) => {
+    stderr = `${stderr}${chunk.toString()}`.slice(-8_192);
+  });
+  child.on("error", (error) => {
+    if (settled) return;
+    settled = true;
+    clearTimeout(timeout);
+    rejectOpen(error);
+  });
+  child.on("close", (code, signal) => {
+    if (settled) return;
+    settled = true;
+    clearTimeout(timeout);
+
+    if (code === 0) {
+      resolveOpen({ url });
+
+      return;
+    }
+
+    const detail = stderr.trim()
+      || `exit code ${code ?? "unknown"}${signal ? ` (${signal})` : ""}`;
+
+    rejectOpen(new Error(`Codex Desktop thread open failed: ${detail}`));
+  });
+});
+
+let maybeDispatchDesktopThread = async (_thread) => {};
+
+const scheduleDesktopDispatch = (thread, delay = 0) => {
+  if (desktopDispatchTimers.has(thread)) return;
+
+  const timer = setTimeout(() => {
+    desktopDispatchTimers.delete(thread);
+    void maybeDispatchDesktopThread(thread);
+  }, delay);
+
+  desktopDispatchTimers.set(thread, timer);
+};
+
+maybeDispatchDesktopThread = async (thread) => {
+  const record = registeredThreads.get(thread);
+
+  if (!record?.appToolsPipe) return;
+
+  const delivery = [...deliveries.values()]
+    .filter((candidate) =>
+      candidate.thread === thread
+      && candidate.transport === "desktop-app"
+      && candidate.status === "queued"
+      && candidate.dispatch !== "desktop-opened")
+    .sort((left, right) => left.createdAt - right.createdAt)[0];
+
+  if (!delivery) return;
+
+  try {
+    if (!delivery.queuedSubmissionId) {
+      const output = await runCodexQueue(thread, delivery.message);
+      delivery.queuedSubmissionId = queuedSubmissionFromOutput(output, thread);
+
+      if (!delivery.queuedSubmissionId) {
+        throw new Error("Codex queue succeeded but did not return a queued submission id.");
+      }
+
+      delivery.dispatch = "persisted";
+      delivery.dispatchError = null;
+      delivery.updatedAt = Date.now();
+      await persistDeliveryState();
+    }
+
+    await openDesktopThread(thread);
+    delivery.dispatch = "desktop-opened";
+    delivery.dispatchError = null;
+    delivery.updatedAt = Date.now();
+    persistDeliveryStateSoon();
+    scheduleDesktopLifecycleCheck(delivery, 0);
+  } catch (cause) {
+    delivery.dispatch = "desktop-wait-failed";
+    delivery.dispatchError = cause instanceof Error ? cause.message : String(cause);
+    delivery.updatedAt = Date.now();
+    persistDeliveryStateSoon();
+  }
+};
+
+const normalizeTitle = (value) => {
+  if (value == null) return null;
+  const title = String(value).replace(/\s+/g, " ").trim();
+
+  if (!title) return null;
+
+  return title.length > 80 ? `${title.slice(0, 79)}…` : title;
+};
+
+const normalizeTimestamp = (value) => Number.isFinite(value) ? Number(value) : null;
+
+const shortThread = (thread) => thread.length > 16 ? `${thread.slice(0, 8)}…${thread.slice(-4)}` : thread;
+
+const appServerSummary = (thread, cwd) => {
+  const id = normalizeThread(thread?.id);
+
+  if (!id) return null;
+
+  const title = normalizeTitle(thread?.name)
+    ?? normalizeTitle(thread?.preview)
+    ?? `Codex ${shortThread(id)}`;
+
+  return {
+    id,
+    title,
+    updatedAt: normalizeTimestamp(thread?.recencyAt ?? thread?.updatedAt),
+    connected: registeredThreads.has(id),
+    cwd,
+  };
+};
+
+const registeredSummary = (record) => ({
+  id: record.id,
+  title: `Codex ${shortThread(record.id)}`,
+  updatedAt: Math.floor(record.seenAt / 1_000),
+  connected: true,
+  cwd: record.cwd,
+});
+
+const listThreadSummaries = async (scopeThread, limit) => {
+  const scopeRecord = scopeThread
+    ? registeredThreads.get(scopeThread) ?? discoveredThreads.get(scopeThread)
+    : activeThread
+      ? registeredThreads.get(activeThread) ?? discoveredThreads.get(activeThread)
+      : null;
+
+  const scopeCwd = scopeRecord?.cwd ?? activeCwd;
+  const preferredThread = scopeThread ?? activeThread;
+  const summaries = [];
+  let appHasMore = false;
+
+  if (scopeCwd) {
+    try {
+      const listed = await runCodexThreadList(scopeCwd, MAX_DISCOVERED_THREADS);
+      const data = Array.isArray(listed?.data) ? listed.data : [];
+      appHasMore = Boolean(listed?.nextCursor);
+
+      for (const item of data) {
+        const summary = appServerSummary(item, scopeCwd);
+
+        if (!summary) continue;
+        discoveredThreads.set(summary.id, summary);
+        summaries.push(summary);
+      }
+    } catch {
+      // Discovery is optional. Registered SessionStart destinations still work without app-server listing.
+    }
+  }
+
+  const byId = new Map(summaries.map((summary) => [summary.id, summary]));
+  const ordered = [];
+  const seen = new Set();
+
+  const push = (summary) => {
+    if (!summary || seen.has(summary.id)) return;
+    seen.add(summary.id);
+    ordered.push({
+      id: summary.id,
+      title: summary.title,
+      updatedAt: summary.updatedAt,
+      connected: registeredThreads.has(summary.id),
+    });
+  };
+
+  if (preferredThread) {
+    push(byId.get(preferredThread)
+      ?? (registeredThreads.get(preferredThread) ? registeredSummary(registeredThreads.get(preferredThread)) : null)
+      ?? discoveredThreads.get(preferredThread));
+  }
+
+  for (const summary of summaries) push(summary);
+
+  for (const record of registeredThreads.values()) {
+    if (scopeCwd && record.cwd && record.cwd !== scopeCwd) continue;
+    push(byId.get(record.id) ?? registeredSummary(record));
+  }
+
+  return {
+    thread: preferredThread,
+    threadDetails: ordered.slice(0, limit),
+    hasMore: appHasMore || ordered.length > limit,
+  };
+};
+
+const threadPayload = () => ({
+  thread: activeThread,
+  threads: [...registeredThreads.keys()],
+});
+
+const hashMessage = (message) => createHash("sha256").update(message).digest("hex");
+
+const turnKey = (thread, turnId) => `${thread}:${turnId}`;
+
+const publicDelivery = (delivery) => ({
+  deliveryId: delivery.id,
+  thread: delivery.thread,
+  transport: delivery.transport,
+  status: delivery.status,
+  turnId: delivery.turnId,
+  queuedSubmissionId: delivery.queuedSubmissionId,
+  clientUserMessageId: delivery.clientUserMessageId,
+  dispatch: delivery.dispatch,
+  dispatchError: delivery.dispatchError,
+  createdAt: delivery.createdAt,
+  updatedAt: delivery.updatedAt,
+});
+
+const deliveryIsTerminal = (delivery) =>
+  delivery.status === "completed" || delivery.status === "interrupted";
+
+const pruneDeliveries = () => {
+  const now = Date.now();
+
+  for (const [id, delivery] of deliveries) {
+    if (!deliveryIsTerminal(delivery)) continue;
+
+    if (now - delivery.updatedAt > TERMINAL_DELIVERY_TTL_MS) {
+      deliveries.delete(id);
+      clearDesktopLifecycleTimer(id);
+      desktopLifecycleChecks.delete(id);
+    }
+  }
+
+  for (const [key, event] of terminalTurnEvents) {
+    if (now - event.at > TERMINAL_DELIVERY_TTL_MS) terminalTurnEvents.delete(key);
+  }
+
+  if (deliveries.size <= MAX_DELIVERIES) return;
+
+  const terminal = [...deliveries.values()]
+    .filter(deliveryIsTerminal)
+    .sort((left, right) => left.updatedAt - right.updatedAt);
+
+  for (const delivery of terminal) {
+    if (deliveries.size <= MAX_DELIVERIES) break;
+    deliveries.delete(delivery.id);
+    clearDesktopLifecycleTimer(delivery.id);
+    desktopLifecycleChecks.delete(delivery.id);
+  }
+};
+
+const createDelivery = (thread, message, transport = "codex-queue") => {
+  pruneDeliveries();
+  const now = Date.now();
+
+  const delivery = {
+    id: randomUUID(),
+    thread,
+    message,
+    messageHash: hashMessage(message),
+    transport,
+    status: "queued",
+    turnId: null,
+    queuedSubmissionId: null,
+    clientUserMessageId: null,
+    dispatch: "persisting",
+    dispatchError: null,
+    createdAt: now,
+    updatedAt: now,
+  };
+
+  deliveries.set(delivery.id, delivery);
+
+  if (delivery.transport === "desktop-app") persistDeliveryStateSoon();
+
+  return delivery;
+};
+
+const xmlEscape = (value) => value
+  .replaceAll("&", "&amp;")
+  .replaceAll("<", "&lt;")
+  .replaceAll(">", "&gt;")
+  .replaceAll('"', "&quot;")
+  .replaceAll("'", "&apos;");
+
+const promptMatchesDelivery = (delivery, prompt) => {
+  if (delivery.messageHash === hashMessage(prompt)) return true;
+
+  if (delivery.transport !== "desktop-app" || !delivery.message) return false;
+
+  return prompt.includes(delivery.message)
+    || prompt.includes(`<input>${xmlEscape(delivery.message)}</input>`);
+};
+
+const turnUserMessageEntries = (turn) => {
+  if (!Array.isArray(turn?.items)) return [];
+
+  return turn.items.flatMap((item) => {
+    if (item?.type !== "userMessage" || !Array.isArray(item.content)) return [];
+
+    const message = item.content
+      .filter((input) => input?.type === "text")
+      .map((input) => String(input.text ?? ""))
+      .join("\n")
+      .trim();
+
+    if (!message) return [];
+
+    return [{
+      message,
+      clientUserMessageId: normalizeThread(item.clientId),
+    }];
+  });
+};
+
+const turnUserMessages = (turn) =>
+  turnUserMessageEntries(turn).map((entry) => entry.message);
+
+const deliveryStateFromTurn = (turn) => {
+  const turnId = normalizeThread(turn?.id);
+  const ended = turn?.completedAt != null && Number.isFinite(Number(turn.completedAt));
+  let status = null;
+
+  if (turn?.status === "inProgress") status = "working";
+
+  if (turn?.status === "interrupted" && !ended) status = "working";
+
+  if (turn?.status === "completed") status = "completed";
+
+  if ((turn?.status === "interrupted" && ended) || turn?.status === "failed") {
+    status = "interrupted";
+  }
+
+  if (!turnId || !status) return null;
+
+  return {
+    turnId,
+    status,
+    dispatchError: turn?.status === "failed"
+      ? normalizeThread(turn?.error?.message) ?? "Codex turn failed."
+      : null,
+    createdAt: Number.isFinite(Number(turn?.startedAt))
+      ? Number(turn.startedAt) * 1_000
+      : null,
+    updatedAt: Number.isFinite(Number(turn?.completedAt))
+      ? Number(turn.completedAt) * 1_000
+      : null,
+  };
+};
+
+const historicalDeliveryMatch = (turns, identity) => {
+  const expectedClientId = normalizeThread(identity?.clientUserMessageId);
+  const expectedMessage = identity?.message?.trim?.() ?? "";
+
+  if (!expectedClientId && !expectedMessage) return null;
+  const expectedHash = expectedMessage ? hashMessage(expectedMessage) : null;
+  const matches = [];
+
+  for (const turn of turns) {
+    for (const entry of turnUserMessageEntries(turn)) {
+      if (expectedClientId && entry.clientUserMessageId !== expectedClientId) continue;
+
+      if (expectedHash && hashMessage(entry.message) !== expectedHash) continue;
+
+      matches.push({ turn, entry });
+    }
+  }
+
+  if (matches.length !== 1) return null;
+
+  const state = deliveryStateFromTurn(matches[0].turn);
+
+  return state ? { ...matches[0], state } : null;
+};
+
+const deliveryTurn = (delivery, turns) => {
+  if (delivery.turnId) {
+    return turns.find((turn) => normalizeThread(turn?.id) === delivery.turnId) ?? null;
+  }
+
+  const earliestStartedAt = delivery.createdAt - DELIVERY_TURN_START_SKEW_MS;
+
+  const matches = turns.filter((turn) => {
+    const turnId = normalizeThread(turn?.id);
+    const startedAt = Number(turn?.startedAt);
+
+    if (!turnId || !Number.isFinite(startedAt) || startedAt * 1_000 < earliestStartedAt) {
+      return false;
+    }
+
+    return turnUserMessages(turn).some((prompt) => promptMatchesDelivery(delivery, prompt));
+  });
+
+  return matches.length === 1 ? matches[0] : null;
+};
+
+const reconcileDesktopDelivery = async (delivery) => {
+  if (delivery.transport !== "desktop-app" || delivery.dispatch !== "desktop-opened") {
+    return;
+  }
+
+  const turns = await runCodexTurnHistory(delivery.thread);
+
+  if (deliveries.get(delivery.id) !== delivery) return;
+  const turn = deliveryTurn(delivery, turns);
+
+  if (!turn) return;
+
+  const state = deliveryStateFromTurn(turn);
+
+  if (!state) return;
+
+  const changed = delivery.turnId !== state.turnId
+    || delivery.status !== state.status
+    || (state.dispatchError && delivery.dispatchError !== state.dispatchError);
+
+  if (!changed) return;
+
+  delivery.turnId = state.turnId;
+  delivery.status = state.status;
+
+  if (state.dispatchError) delivery.dispatchError = state.dispatchError;
+  delivery.updatedAt = Date.now();
+  await persistDeliveryState();
+  scheduleIdleShutdown();
+};
+
+const captureQueuedIdentity = async (delivery) => {
+  if (!delivery.queuedSubmissionId) return;
+
+  try {
+    const lookup = await runCodexQueueLookup(delivery.thread, delivery.queuedSubmissionId);
+
+    if (lookup.submission) {
+      delivery.clientUserMessageId = normalizeThread(lookup.submission.clientUserMessageId);
+
+      return;
+    }
+  } catch {
+    // Queue delivery already succeeded. Identity enrichment is best-effort here.
+  }
+
+  try {
+    const turns = await runCodexTurnHistory(delivery.thread);
+    const turn = deliveryTurn(delivery, turns);
+
+    if (!turn) return;
+
+    const entry = turnUserMessageEntries(turn).find((candidate) =>
+      hashMessage(candidate.message) === delivery.messageHash);
+
+    if (entry?.clientUserMessageId) {
+      delivery.clientUserMessageId = entry.clientUserMessageId;
+    }
+
+    const state = deliveryStateFromTurn(turn);
+
+    if (state) {
+      delivery.turnId = state.turnId;
+      delivery.status = state.status;
+
+      if (state.dispatchError) delivery.dispatchError = state.dispatchError;
+    }
+  } catch {
+    // A later delivery poll can still reconcile through history.
+  }
+};
+
+const scheduleDesktopLifecycleCheck = (delivery, delay = DESKTOP_LIFECYCLE_POLL_MS) => {
+  if (shutdownStarted
+    || deliveries.get(delivery.id) !== delivery
+    || !deliveryNeedsDesktopLifecycleCheck(delivery)) {
+    clearDesktopLifecycleTimer(delivery.id);
+
+    return;
+  }
+
+  if (desktopLifecycleChecks.has(delivery.id)
+    || desktopLifecycleTimers.has(delivery.id)) {
+    return;
+  }
+
+  const timer = setTimeout(() => {
+    desktopLifecycleTimers.delete(delivery.id);
+
+    if (shutdownStarted
+      || deliveries.get(delivery.id) !== delivery
+      || !deliveryNeedsDesktopLifecycleCheck(delivery)) {
+      return;
+    }
+
+    const check = reconcileDesktopDelivery(delivery)
+      .catch(() => undefined)
+      .finally(() => {
+        if (desktopLifecycleChecks.get(delivery.id) === check) {
+          desktopLifecycleChecks.delete(delivery.id);
+        }
+
+        if (!shutdownStarted
+          && deliveries.get(delivery.id) === delivery
+          && deliveryNeedsDesktopLifecycleCheck(delivery)) {
+          scheduleDesktopLifecycleCheck(delivery);
+        } else {
+          clearDesktopLifecycleTimer(delivery.id);
+        }
+      });
+
+    desktopLifecycleChecks.set(delivery.id, check);
+  }, Math.max(0, delay));
+
+  timer.unref?.();
+  desktopLifecycleTimers.set(delivery.id, timer);
+};
+
+const markPromptStarted = (thread, turnId, prompt) => {
+  const delivery = [...deliveries.values()]
+    .filter((candidate) =>
+      candidate.thread === thread
+      && promptMatchesDelivery(candidate, prompt)
+      && candidate.status === "queued")
+    .sort((a, b) => a.createdAt - b.createdAt)[0];
+
+  if (!delivery) return null;
+  delivery.status = "working";
+  delivery.turnId = turnId;
+  delivery.updatedAt = Date.now();
+
+  if (delivery.transport === "desktop-app") persistDeliveryStateSoon();
+  const terminal = terminalTurnEvents.get(turnKey(thread, turnId));
+
+  if (terminal) {
+    delivery.status = terminal.status;
+    delivery.updatedAt = Math.max(delivery.updatedAt, terminal.at);
+    terminalTurnEvents.delete(turnKey(thread, turnId));
+
+    if (delivery.transport === "desktop-app") persistDeliveryStateSoon();
+  }
+
+  return delivery;
+};
+
+const markTurnTerminal = (thread, turnId, status) => {
+  const delivery = [...deliveries.values()].find((candidate) =>
+    candidate.thread === thread
+    && candidate.turnId === turnId
+    && candidate.status === "working");
+
+  if (delivery) {
+    delivery.status = status;
+    delivery.updatedAt = Date.now();
+
+    if (delivery.transport === "desktop-app") {
+      persistDeliveryStateSoon();
+      clearDesktopLifecycleTimer(delivery.id);
+    }
+
+    scheduleIdleShutdown();
+
+    return delivery;
+  }
+
+  terminalTurnEvents.set(turnKey(thread, turnId), { status, at: Date.now() });
+
+  return null;
+};
+
+const desktopOwnsLifecycle = (thread) =>
+  Boolean(registeredThreads.get(thread)?.appToolsPipe)
+  || [...deliveries.values()].some((delivery) =>
+    delivery.thread === thread && delivery.transport === "desktop-app");
+
+await loadDeliveryState();
+
+for (const delivery of deliveries.values()) scheduleDesktopLifecycleCheck(delivery, 0);
+
+let successfulSends = 0;
+
+server = createServer(async (request, response) => {
+  const originHeaderPresent = Object.hasOwn(request.headers, "origin");
+  const origin = [request.headers.origin].flat().find((value) => value !== undefined);
+
+  if (!originAllowed(origin)) {
+    if (request.method === "GET" && request.url === "/health") {
+      writeJson(response, 200, {
+        ok: true,
+        bridge: {
+          name: BRIDGE_IDENTITY.name,
+          protocol: BRIDGE_IDENTITY.protocol,
+          capabilities: BRIDGE_IDENTITY.capabilities,
+        },
+        access: { allowed: false },
+      }, origin, true);
+
+      return;
+    }
+
+    writeJson(
+      response,
+      403,
+      { ok: false, error: `Origin is not allowed: ${origin}` },
+      origin,
+      true,
+    );
+
+    return;
+  }
+
+  if (request.method === "OPTIONS") {
+    response.writeHead(204, corsHeaders(origin));
+    response.end();
+
+    return;
+  }
+
+  if (request.method === "POST" && request.url === "/shutdown") {
+    if (originHeaderPresent) {
+      writeJson(response, 403, { ok: false, error: "Bridge shutdown is local-process-only." }, origin);
+
+      return;
+    }
+
+    const state = bridgeState();
+
+    if (!state.idle) {
+      writeJson(response, 409, {
+        ok: false,
+        error: "Mesurer Codex Bridge is still in use and cannot shut down yet.",
+        bridgeState: state,
+      }, origin);
+
+      return;
+    }
+
+    response.setHeader("Connection", "close");
+    response.once("finish", () => {
+      void shutdownBridge();
+    });
+    writeJson(response, 200, { ok: true, bridgeState: state }, origin);
+
+    return;
+  }
+
+  if (originHeaderPresent
+    && !(request.method === "GET" && request.url === "/health")
+    && request.headers["x-mesurer-bridge-instance"] !== BRIDGE_INSTANCE_ID) {
+    writeJson(response, 409, {
+      ok: false,
+      error: "Mesurer Codex Bridge instance changed. Reconnect before sending another request.",
+    }, origin);
+
+    return;
+  }
+
+  if (request.method === "GET" && request.url === "/health") {
+    writeJson(response, 200, {
+      ok: true,
+      bridge: BRIDGE_IDENTITY,
+      bridgeState: bridgeState(),
+      access: { allowed: true },
+      ...threadPayload(),
+    }, origin);
+
+    return;
+  }
+
+  if (request.method === "GET" && request.url?.startsWith("/deliveries/")) {
+    pruneDeliveries();
+    const url = new URL(request.url, DEFAULT_BRIDGE);
+    const prefix = "/deliveries/";
+    const deliveryId = decodeURIComponent(url.pathname.slice(prefix.length));
+    const delivery = deliveries.get(deliveryId);
+
+    if (!delivery) {
+      writeJson(response, 404, { ok: false, error: `Codex delivery is not available: ${deliveryId}` }, origin);
+
+      return;
+    }
+
+    scheduleDesktopLifecycleCheck(delivery);
+    writeJson(response, 200, { ok: true, ...publicDelivery(delivery) }, origin);
+
+    return;
+  }
+
+  if (request.method === "POST" && request.url === "/deliveries/restore") {
+    try {
+      const body = await readJsonBody(request);
+      const deliveryId = normalizeThread(body?.deliveryId);
+      const thread = normalizeThread(body?.thread);
+      const queuedSubmissionId = normalizeThread(body?.queuedSubmissionId);
+      const clientUserMessageId = normalizeThread(body?.clientUserMessageId);
+      const recoveryMessage = body?.message?.trim?.() ?? "";
+
+      if (!deliveryId || !thread) {
+        writeJson(response, 400, { ok: false, error: "deliveryId and thread are required." }, origin);
+
+        return;
+      }
+
+      if (!registeredThreads.has(thread) && !discoveredThreads.has(thread)) {
+        writeJson(response, 409, {
+          ok: false,
+          error: `Codex thread is not available to this bridge: ${thread}`,
+        }, origin);
+
+        return;
+      }
+
+      const existing = deliveries.get(deliveryId);
+
+      if (existing) {
+        if (clientUserMessageId && existing.clientUserMessageId
+          && clientUserMessageId !== existing.clientUserMessageId) {
+          writeJson(response, 409, {
+            ok: false,
+            error: "Codex delivery client-message identity does not match the persisted delivery.",
+          }, origin);
+
+          return;
+        }
+
+        if (clientUserMessageId && !existing.clientUserMessageId) {
+          existing.clientUserMessageId = clientUserMessageId;
+          await persistDeliveryState();
+        }
+
+        if (existing.transport === "desktop-app") {
+          scheduleDesktopDispatch(existing.thread);
+          scheduleDesktopLifecycleCheck(existing, 0);
+        }
+
+        writeJson(response, 200, { ok: true, restored: false, ...publicDelivery(existing) }, origin);
+
+        return;
+      }
+
+      const lookup = await runCodexQueueLookup(thread, queuedSubmissionId);
+
+      if (lookup.submission) {
+        const message = queuedSubmissionMessage(lookup.submission);
+        const queuedClientUserMessageId = normalizeThread(lookup.submission.clientUserMessageId);
+
+        if (!message) {
+          writeJson(response, 409, {
+            ok: false,
+            error: "The queued Codex submission is not a single text message and cannot be restored safely.",
+          }, origin);
+
+          return;
+        }
+
+        if (clientUserMessageId && queuedClientUserMessageId
+          && clientUserMessageId !== queuedClientUserMessageId) {
+          writeJson(response, 409, {
+            ok: false,
+            error: "Codex queued submission client-message identity does not match Mesurer state.",
+          }, origin);
+
+          return;
+        }
+
+        if (recoveryMessage && hashMessage(recoveryMessage) !== hashMessage(message)) {
+          writeJson(response, 409, {
+            ok: false,
+            error: "Codex queued submission text does not match the saved Mesurer feedback.",
+          }, origin);
+
+          return;
+        }
+
+        pruneDeliveries();
+        const now = Date.now();
+        const record = registeredThreads.get(thread);
+        const transport = record?.appToolsPipe ? "desktop-app" : "codex-queue";
+
+        const delivery = {
+          id: deliveryId,
+          thread,
+          message,
+          messageHash: hashMessage(message),
+          transport,
+          status: "queued",
+          turnId: null,
+          queuedSubmissionId: normalizeThread(lookup.submission.id) ?? queuedSubmissionId,
+          clientUserMessageId: queuedClientUserMessageId ?? clientUserMessageId,
+          dispatch: "persisted",
+          dispatchError: null,
+          createdAt: now,
+          updatedAt: now,
+        };
+
+        deliveries.set(delivery.id, delivery);
+        await persistDeliveryState();
+
+        if (transport === "desktop-app") {
+          scheduleDesktopDispatch(thread);
+        } else {
+          try {
+            const wake = await resumeColdCodexThread(thread);
+            delivery.dispatch = wake.action;
+            delivery.updatedAt = Date.now();
+          } catch (cause) {
+            delivery.dispatch = "wake-failed";
+            delivery.dispatchError = cause instanceof Error ? cause.message : String(cause);
+            delivery.updatedAt = Date.now();
+          }
+
+          persistDeliveryStateSoon();
+        }
+
+        writeJson(response, 200, {
+          ok: true,
+          restored: true,
+          ...publicDelivery(delivery),
+        }, origin);
+
+        return;
+      }
+
+      if (lookup.ambiguous) {
+        writeJson(response, 409, {
+          ok: false,
+          error: "Multiple queued Codex submissions exist for this thread; an exact queuedSubmissionId is required to restore the delivery safely.",
+        }, origin);
+
+        return;
+      }
+
+      const turns = await runCodexTurnHistory(thread);
+
+      const historical = historicalDeliveryMatch(turns, {
+        clientUserMessageId,
+        message: recoveryMessage,
+      });
+
+      if (!historical) {
+        const error = queuedSubmissionId
+          ? `Codex queued submission is not available and no unique matching turn exists in history: ${queuedSubmissionId}`
+          : "No queued Codex submission or unique matching turn is available to restore for this thread.";
+
+        writeJson(response, 409, { ok: false, error }, origin);
+
+        return;
+      }
+
+      const record = registeredThreads.get(thread);
+      const transport = record?.appToolsPipe ? "desktop-app" : "codex-queue";
+      const state = historical.state;
+      const now = Date.now();
+
+      const delivery = {
+        id: deliveryId,
+        thread,
+        message: historical.entry.message,
+        messageHash: hashMessage(historical.entry.message),
+        transport,
+        status: state.status,
+        turnId: state.turnId,
+        queuedSubmissionId,
+        clientUserMessageId: historical.entry.clientUserMessageId ?? clientUserMessageId,
+        dispatch: transport === "desktop-app" ? "desktop-opened" : "persisted",
+        dispatchError: state.dispatchError,
+        createdAt: state.createdAt ?? now,
+        updatedAt: state.updatedAt ?? now,
+      };
+
+      pruneDeliveries();
+      deliveries.set(delivery.id, delivery);
+      await persistDeliveryState();
+
+      writeJson(response, 200, {
+        ok: true,
+        restored: true,
+        ...publicDelivery(delivery),
+      }, origin);
+    } catch (cause) {
+      const error = cause instanceof Error ? cause.message : String(cause);
+      writeJson(response, 502, { ok: false, error }, origin);
+    }
+
+    return;
+  }
+
+  if (request.method === "GET" && request.url?.startsWith("/threads")) {
+    const url = new URL(request.url, DEFAULT_BRIDGE);
+
+    if (url.pathname !== "/threads") {
+      writeJson(response, 404, { ok: false, error: "Not found." }, origin);
+
+      return;
+    }
+
+    const requestedLimit = Number(url.searchParams.get("limit") ?? "5");
+
+    const limit = Number.isInteger(requestedLimit)
+      ? Math.min(MAX_DISCOVERED_THREADS, Math.max(1, requestedLimit))
+      : 5;
+
+    const scopeThread = normalizeThread(url.searchParams.get("thread")) ?? activeThread;
+
+    if (scopeThread && !registeredThreads.has(scopeThread) && !discoveredThreads.has(scopeThread)) {
+      writeJson(response, 409, { ok: false, error: `Codex thread is not known to this bridge: ${scopeThread}` }, origin);
+
+      return;
+    }
+
+    const payload = await listThreadSummaries(scopeThread, limit);
+    writeJson(response, 200, { ok: true, ...payload }, origin);
+
+    return;
+  }
+
+  if (request.method === "POST" && request.url === "/threads/unregister") {
+    if (originHeaderPresent) {
+      writeJson(response, 403, {
+        ok: false,
+        error: "Thread unregistration is available only to a local process, not a browser Origin.",
+      }, origin);
+
+      return;
+    }
+
+    try {
+      const body = await readJsonBody(request);
+      const thread = normalizeThread(body?.thread);
+
+      if (!thread) {
+        writeJson(response, 400, { ok: false, error: "thread must be a non-empty string." }, origin);
+
+        return;
+      }
+
+      const removed = unregisterThread(thread);
+      writeJson(response, 200, {
+        ok: true,
+        removed,
+        ...threadPayload(),
+      }, origin);
+    } catch (cause) {
+      const error = cause instanceof Error ? cause.message : String(cause);
+      writeJson(response, 400, { ok: false, error }, origin);
+    }
+
+    return;
+  }
+
+  if (request.method === "POST" && request.url === "/threads/register") {
+    if (originHeaderPresent) {
+      writeJson(response, 403, {
+        ok: false,
+        error: "Thread registration is available only to a local process, not a browser Origin.",
+      }, origin);
+
+      return;
+    }
+
+    try {
+      const body = await readJsonBody(request);
+      const thread = normalizeThread(body?.thread);
+      const cwd = normalizeCwd(body?.cwd);
+      const appToolsPipe = normalizeThread(body?.appToolsPipe);
+      const codexHome = normalizeCwd(body?.codexHome);
+
+      if (!thread) {
+        writeJson(response, 400, { ok: false, error: "thread must be a non-empty string." }, origin);
+
+        return;
+      }
+
+      registerThread(thread, cwd, { appToolsPipe, codexHome });
+
+      if (appToolsPipe) scheduleDesktopDispatch(thread);
+      writeJson(response, 200, { ok: true, ...threadPayload() }, origin);
+    } catch (cause) {
+      const error = cause instanceof Error ? cause.message : String(cause);
+      writeJson(response, 400, { ok: false, error }, origin);
+    }
+
+    return;
+  }
+
+  if (request.method === "POST" && request.url === "/lifecycle") {
+    if (originHeaderPresent) {
+      writeJson(response, 403, {
+        ok: false,
+        error: "Codex lifecycle updates are available only to a local process, not a browser Origin.",
+      }, origin);
+
+      return;
+    }
+
+    try {
+      const body = await readJsonBody(request);
+      const event = body?.event;
+      const thread = normalizeThread(body?.sessionId);
+      const turnId = normalizeThread(body?.turnId);
+
+      if (!thread || !turnId) {
+        writeJson(response, 400, { ok: false, error: "sessionId and turnId are required." }, origin);
+
+        return;
+      }
+
+      if (desktopOwnsLifecycle(thread)) {
+        writeJson(response, 200, {
+          ok: true,
+          matched: false,
+          ignored: "desktop-history-authoritative",
+        }, origin);
+
+        return;
+      }
+
+      let delivery = null;
+
+      if (event === "UserPromptSubmit") {
+        const prompt = body?.prompt?.trim?.() ?? "";
+
+        if (!prompt) {
+          writeJson(response, 400, { ok: false, error: "UserPromptSubmit requires prompt." }, origin);
+
+          return;
+        }
+
+        delivery = markPromptStarted(thread, turnId, prompt);
+      } else if (event === "Stop") {
+        delivery = markTurnTerminal(thread, turnId, "completed");
+        scheduleDesktopDispatch(thread);
+      } else if (event === "Interrupt") {
+        delivery = markTurnTerminal(thread, turnId, "interrupted");
+        scheduleDesktopDispatch(thread);
+      } else {
+        writeJson(response, 400, { ok: false, error: `Unsupported Codex lifecycle event: ${event ?? "<missing>"}` }, origin);
+
+        return;
+      }
+
+      pruneDeliveries();
+
+      if (delivery) {
+        writeJson(response, 200, {
+          ok: true,
+          matched: true,
+          ...publicDelivery(delivery),
+        }, origin);
+      } else {
+        writeJson(response, 200, { ok: true, matched: false }, origin);
+      }
+    } catch (cause) {
+      const error = cause instanceof Error ? cause.message : String(cause);
+      writeJson(response, 400, { ok: false, error }, origin);
+    }
+
+    return;
+  }
+
+  if (request.method === "POST" && request.url === "/target") {
+    try {
+      const body = await readJsonBody(request);
+      const thread = normalizeThread(body?.thread);
+
+      if (!thread) {
+        writeJson(response, 400, { ok: false, error: "thread must be a non-empty string." }, origin);
+
+        return;
+      }
+
+      const record = registeredThreads.get(thread) ?? discoveredThreads.get(thread);
+
+      if (!record) {
+        writeJson(response, 409, {
+          ok: false,
+          error: `Codex thread is not available to this bridge: ${thread}`,
+        }, origin);
+
+        return;
+      }
+
+      activeThread = thread;
+
+      if (record.cwd) activeCwd = record.cwd;
+      writeJson(response, 200, { ok: true, ...threadPayload() }, origin);
+    } catch (cause) {
+      const error = cause instanceof Error ? cause.message : String(cause);
+      writeJson(response, 400, { ok: false, error }, origin);
+    }
+
+    return;
+  }
+
+  if (request.method !== "POST" || request.url !== "/send") {
+    writeJson(response, 404, { ok: false, error: "Not found." }, origin);
+
+    return;
+  }
+
+  try {
+    const body = await readJsonBody(request);
+    const message = body?.message?.trim?.() ?? "";
+    const requestedThread = normalizeThread(body?.thread);
+    const thread = requestedThread ?? activeThread;
+
+    if (!message) {
+      writeJson(response, 400, { ok: false, error: "message must be a non-empty string." }, origin);
+
+      return;
+    }
+
+    if (!thread) {
+      writeJson(response, 409, {
+        ok: false,
+        error: "No Codex thread is registered. Start the bridge from Codex, pass --thread, or run mesurer-codex --register-current.",
+      }, origin);
+
+      return;
+    }
+
+    if (!registeredThreads.has(thread) && !discoveredThreads.has(thread)) {
+      writeJson(response, 409, {
+        ok: false,
+        error: `Codex thread is not available to this bridge: ${thread}`,
+      }, origin);
+
+      return;
+    }
+
+    const record = registeredThreads.get(thread);
+
+    if (record?.appToolsPipe) {
+      const delivery = createDelivery(thread, message, "desktop-app");
+      let output;
+
+      try {
+        output = await runCodexQueue(thread, message);
+      } catch (cause) {
+        deliveries.delete(delivery.id);
+        persistDeliveryStateSoon();
+        throw cause;
+      }
+
+      delivery.queuedSubmissionId = queuedSubmissionFromOutput(output, thread);
+
+      if (!delivery.queuedSubmissionId) {
+        deliveries.delete(delivery.id);
+        persistDeliveryStateSoon();
+        throw new Error("Codex queue succeeded but did not return a queued submission id.");
+      }
+
+      delivery.dispatch = "persisted";
+      delivery.updatedAt = Date.now();
+      await captureQueuedIdentity(delivery);
+      await persistDeliveryState();
+      scheduleDesktopDispatch(thread);
+      successfulSends += 1;
+      writeJson(response, 200, {
+        ok: true,
+        thread,
+        output,
+        delivery: "queued",
+        ...publicDelivery(delivery),
+      }, origin);
+
+      if (values.once && successfulSends >= 1) setImmediate(() => void shutdownBridge());
+
+      return;
+    }
+
+    const delivery = createDelivery(thread, message, "codex-queue");
+    let output;
+
+    try {
+      output = await runCodexQueue(thread, message);
+    } catch (cause) {
+      deliveries.delete(delivery.id);
+      persistDeliveryStateSoon();
+      throw cause;
+    }
+
+    delivery.queuedSubmissionId = queuedSubmissionFromOutput(output, thread);
+    delivery.dispatch = "persisted";
+    delivery.updatedAt = Date.now();
+    await captureQueuedIdentity(delivery);
+
+    if (delivery.queuedSubmissionId && delivery.status === "queued") {
+      try {
+        const wake = await resumeColdCodexThread(thread);
+        delivery.dispatch = wake.action;
+        delivery.updatedAt = Date.now();
+      } catch (cause) {
+        delivery.dispatch = "wake-failed";
+        delivery.dispatchError = cause instanceof Error ? cause.message : String(cause);
+        delivery.updatedAt = Date.now();
+      }
+    } else {
+      delivery.dispatch = "untracked";
+      delivery.dispatchError = "Codex queue succeeded but did not return a queued submission id.";
+      delivery.updatedAt = Date.now();
+    }
+
+    persistDeliveryStateSoon();
+
+    successfulSends += 1;
+    writeJson(response, 200, {
+      ok: true,
+      thread,
+      output,
+      delivery: "queued",
+      ...publicDelivery(delivery),
+    }, origin);
+
+    if (values.once && successfulSends >= 1) setImmediate(() => void shutdownBridge());
+  } catch (cause) {
+    const error = cause instanceof Error ? cause.message : String(cause);
+    writeJson(response, 502, { ok: false, error }, origin);
+  }
+});
+
+server.on("error", (error) => {
+  process.stderr.write(`Mesurer Codex bridge failed: ${error.message}\n`);
+  process.exitCode = 1;
+});
+
+server.listen(parsedPort, "127.0.0.1", () => {
+  for (const [thread, record] of registeredThreads) {
+    if (record.appToolsPipe) scheduleDesktopDispatch(thread);
+  }
+
+  const address = server.address();
+  const port = address?.port ?? parsedPort;
+  const url = `http://127.0.0.1:${port}`;
+  console.log(`Mesurer Codex bridge listening on ${url}`);
+
+  if (activeThread) console.log(`Active Codex thread: ${activeThread}`);
+  else console.log("No Codex thread is registered yet.");
+  console.log(`BRIDGE_URL=${url}`);
+
+  if (activeThread) console.log(`BRIDGE_THREAD=${activeThread}`);
+});
+
+async function shutdownBridge() {
+  if (shutdownStarted) return;
+
+  shutdownStarted = true;
+  cancelIdleShutdown();
+
+  if (ownerHealthTimer) {
+    clearInterval(ownerHealthTimer);
+    ownerHealthTimer = null;
+  }
+
+  for (const timer of desktopDispatchTimers.values()) clearTimeout(timer);
+  desktopDispatchTimers.clear();
+
+  for (const timer of desktopLifecycleTimers.values()) clearTimeout(timer);
+  desktopLifecycleTimers.clear();
+  desktopLifecycleChecks.clear();
+
+  const children = [...ownedChildren];
+
+  for (const child of children) {
+    if (child.exitCode === null && child.signalCode === null) {
+      try {
+        child.kill("SIGTERM");
+      } catch {}
+    }
+  }
+
+  const closeServer = new Promise((resolve) => {
+    if (!server?.listening) {
+      resolve();
+
+      return;
+    }
+
+    server.close(() => resolve());
+    server.closeAllConnections?.();
+  });
+
+  const childExit = Promise.allSettled(children.map((child) => new Promise((resolve) => {
+    if (child.exitCode !== null || child.signalCode !== null) {
+      resolve();
+
+      return;
+    }
+
+    child.once("close", resolve);
+    child.once("error", resolve);
+  })));
+
+  await Promise.race([
+    Promise.all([closeServer, childExit]),
+    new Promise((resolve) => setTimeout(resolve, OWNED_CHILD_SHUTDOWN_GRACE_MS)),
+  ]);
+
+  for (const child of ownedChildren) {
+    if (child.exitCode === null && child.signalCode === null) {
+      try {
+        child.kill("SIGKILL");
+      } catch {}
+    }
+  }
+
+  process.exit(0);
+}
+
+process.on("SIGINT", () => {
+  void shutdownBridge();
+});
+
+process.on("SIGTERM", () => {
+  void shutdownBridge();
+});