agent-shim 8.8.0 → 8.9.0

package/dist/index.mjs

@@ -3066,1326 +3066,1916 @@ function realConnectCertStore(paths) {
 // src/frontdoor/connectEffects.ts
 import dns from "node:dns";
 import * as http from "node:http";
-import * as https from "node:https";
+import * as https2 from "node:https";
 import * as net2 from "node:net";
 import * as tls from "node:tls";
-var UPSTREAM_LOCAL_PORT_START = 47900;
-var UPSTREAM_LOCAL_PORT_END = 47919;
-var UPSTREAM_LOCAL_PORT_COUNT = UPSTREAM_LOCAL_PORT_END - UPSTREAM_LOCAL_PORT_START + 1;
-var nextUpstreamLocalPort = UPSTREAM_LOCAL_PORT_START;
-function upstreamLocalPort() {
-  const port = nextUpstreamLocalPort;
-  nextUpstreamLocalPort = nextUpstreamLocalPort === UPSTREAM_LOCAL_PORT_END ? UPSTREAM_LOCAL_PORT_START : nextUpstreamLocalPort + 1;
-  return port;
+
+// src/codex/http.ts
+var HTTP_STATUS = {
+  ok: 200,
+  badRequest: 400,
+  unauthorized: 401,
+  forbidden: 403,
+  notFound: 404,
+  methodNotAllowed: 405,
+  payloadTooLarge: 413,
+  tooManyRequests: 429,
+  /** Not sent to anyone: the client is gone. Recorded for a response abandoned because the client disconnected, following the convention nginx uses for the same case. */
+  clientClosedRequest: 499,
+  internalServerError: 500,
+  badGateway: 502
+};
+
+// src/frontdoor/rcControl.ts
+import * as https from "node:https";
+
+// src/frontdoor/rcSessions.ts
+var RC_SESSIONS_PATH_PREFIX = "/v1/code/sessions";
+var RC_SESSION_ID_PREFIX = "cse_";
+var RC_IDLE_EXPIRY_MS = 45e3;
+var RC_CREATE_RESPONSE_CAP_BYTES = 8192;
+var CONFLICT_REASON_HEADER = "x-ccr-conflict-reason";
+var RC_STREAM_WORKER_SOURCE = "worker";
+var RC_PENDING_DEADLINE_MS = 14e3;
+var RC_REQUEST_PARSE_CAP_BYTES = 262144;
+var RC_PENDING_SUMMARY_EXCERPT_CHARS = 300;
+var SUCCESS_STATUS_MAX_EXCLUSIVE = 300;
+function isSuccessful(status) {
+  return status >= HTTP_STATUS.ok && status < SUCCESS_STATUS_MAX_EXCLUSIVE;
 }
-var realAddressLookup = (host, _options, callback) => {
-  if (net2.isIP(host) !== 0) {
-    callback(null, [{ address: host, family: net2.isIP(host) }]);
-    return;
+function singleHeader(headers, name) {
+  const value = headers[name];
+  return typeof value === "string" ? value : void 0;
+}
+var OAUTH_AUTHORIZATION_PREFIX = "Bearer sk-ant-oat";
+function oauthAuthorizationOf(headers) {
+  const value = singleHeader(headers, "authorization");
+  return value?.startsWith(OAUTH_AUTHORIZATION_PREFIX) === true ? value : void 0;
+}
+function sessionCreateId(body) {
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return void 0;
   }
-  dns.resolve4(host, (error, addresses) => {
-    if (error !== null) {
-      callback(error, [{ address: "", family: 4 }]);
-      return;
-    }
-    const first = addresses[0];
-    if (first === void 0) {
-      callback(new Error(`no A record for ${host}`), [{ address: "", family: 4 }]);
-      return;
-    }
-    callback(null, [{ address: first, family: 4 }]);
-  });
-};
-var HTTP_PORT = 80;
-var HELD_PORT_ERRNOS = /* @__PURE__ */ new Set(["EADDRINUSE", "EADDRNOTAVAIL"]);
-async function dialOnce(connectOptions) {
-  return await new Promise((resolve) => {
-    const socket = net2.connect(connectOptions);
-    socket.once("connect", () => {
-      resolve({ error: null, socket });
-    });
-    socket.once("error", (error) => {
-      resolve({ error, socket });
-    });
-  });
+  if (typeof parsed !== "object" || parsed === null || !("session" in parsed)) {
+    return void 0;
+  }
+  const session = parsed.session;
+  if (typeof session !== "object" || session === null || !("id" in session)) {
+    return void 0;
+  }
+  const id = session.id;
+  return typeof id === "string" && id.startsWith(RC_SESSION_ID_PREFIX) ? id : void 0;
 }
-function dialTarget(options, defaultPort) {
-  return { host: typeof options.host === "string" ? options.host : "", port: typeof options.port === "number" ? options.port : defaultPort };
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function literalDial(target) {
-  return net2.connect({ host: target.host, port: target.port });
+function parseJsonObject(body) {
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return void 0;
+  }
+  return isRecord2(parsed) ? parsed : void 0;
 }
-async function reservedDial(target) {
-  for (let attempt = 0; ; attempt += 1) {
-    const outcome = await dialOnce({ host: target.host, port: target.port, localPort: upstreamLocalPort(), lookup: realAddressLookup });
-    if (outcome.error === null) {
-      return outcome;
+function nonEmptyString(record, field) {
+  const value = record === void 0 ? void 0 : record[field];
+  return typeof value === "string" && value !== "" ? value : void 0;
+}
+function finiteNumber(record, field) {
+  const value = record === void 0 ? void 0 : record[field];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function excerpt(text) {
+  return text.length <= RC_PENDING_SUMMARY_EXCERPT_CHARS ? text : `${text.slice(0, RC_PENDING_SUMMARY_EXCERPT_CHARS)}...`;
+}
+function payloadEventsOf(body) {
+  const parsed = parseJsonObject(body);
+  const events = parsed === void 0 ? void 0 : parsed.events;
+  if (!Array.isArray(events)) {
+    return [];
+  }
+  const payloads = [];
+  for (const event of events) {
+    if (!isRecord2(event)) {
+      continue;
     }
-    const held = outcome.error.code !== void 0 && HELD_PORT_ERRNOS.has(outcome.error.code);
-    if (!held || attempt === UPSTREAM_LOCAL_PORT_COUNT - 1) {
-      return outcome;
+    const payload = event.payload;
+    if (!isRecord2(payload)) {
+      continue;
     }
+    payloads.push(payload);
   }
+  return payloads;
 }
-function requestServername(options, fallback) {
-  return "servername" in options && typeof options.servername === "string" && options.servername !== "" ? options.servername : fallback;
-}
-var ExemptHttpAgent = class extends http.Agent {
-  // A reserved-port dial that has to retry cannot produce its socket synchronously, so it settles first and arrives through the callback (node's documented asynchronous createConnection form); a literal dial has nothing to retry and keeps node's own synchronous shape.
-  createConnection(options, oncreate) {
-    const target = dialTarget(options, HTTP_PORT);
-    if (net2.isIP(target.host) !== 0) {
-      return literalDial(target);
-    }
-    void reservedDial(target).then((outcome) => {
-      oncreate?.(outcome.error, outcome.socket);
-    });
+function pendingOfControlRequestPayload(payload) {
+  if (payload.type !== "control_request") {
     return void 0;
   }
-};
-var ExemptTlsAgent = class extends https.Agent {
-  // The same split as the plain sibling: a literal dial wraps TLS around the socket node's own agent would have returned, a reserved dial settles (retries included) first and arrives through the callback, which is exactly where node's own agent wraps its own dials.
-  createConnection(options, oncreate) {
-    const target = dialTarget(options, HTTPS_PORT);
-    if (net2.isIP(target.host) !== 0) {
-      return tls.connect({ socket: literalDial(target), servername: requestServername(options, target.host), ...tlsFacts(options) });
-    }
-    void reservedDial(target).then((outcome) => {
-      if (outcome.error !== null) {
-        oncreate?.(outcome.error, outcome.socket);
-        return;
-      }
-      oncreate?.(null, tls.connect({ socket: outcome.socket, servername: requestServername(options, target.host), ...tlsFacts(options) }));
-    });
+  const requestId = nonEmptyString(payload, "request_id") ?? nonEmptyString(payload, "uuid");
+  if (requestId === void 0) {
     return void 0;
   }
-};
-function tlsFacts(options) {
-  const facts = {};
-  if ("ca" in options && Array.isArray(options.ca)) {
-    facts.ca = options.ca;
+  const request4 = isRecord2(payload.request) ? payload.request : void 0;
+  const subtype = nonEmptyString(request4, "subtype");
+  const type = subtype ?? "control_request";
+  let summary = "";
+  if (subtype === "can_use_tool") {
+    const toolName = nonEmptyString(request4, "tool_name") ?? "unknown tool";
+    const input = request4 === void 0 ? void 0 : request4.input;
+    summary = input === void 0 ? toolName : `${toolName} ${excerpt(JSON.stringify(input))}`;
+  } else if (request4 !== void 0) {
+    summary = excerpt(JSON.stringify(request4));
   }
-  if ("rejectUnauthorized" in options && typeof options.rejectUnauthorized === "boolean") {
-    facts.rejectUnauthorized = options.rejectUnauthorized;
+  return { requestId, type, summary };
+}
+function answeredRequestIdsOfControlResponsePayload(payload) {
+  if (payload.type !== "control_response") {
+    return [];
   }
-  return facts;
+  const response = isRecord2(payload.response) ? payload.response : void 0;
+  const id = nonEmptyString(response, "request_id") ?? nonEmptyString(payload, "request_id") ?? nonEmptyString(payload, "uuid");
+  return id === void 0 ? [] : [id];
 }
-function realRcEventDial(target = { host: CONNECT_INTERCEPT_HOST, port: HTTPS_PORT }) {
-  const agent = new ExemptTlsAgent();
-  return {
-    writeEvents: async (sessionId, headers, body) => await new Promise((resolve, reject) => {
-      const options = {
-        host: target.host,
-        port: target.port,
-        method: "POST",
-        path: `/v1/code/sessions/${encodeURIComponent(sessionId)}/events`,
-        // The Host header names the host whose API this is, not the address dialled: a redirected test dials a loopback stand-in while still speaking to the API host by name, exactly as the forwarded paths present their SNI.
-        headers: { ...headers, host: target.servername ?? target.host, "content-length": String(Buffer.byteLength(body, "utf8")) },
-        agent
-      };
-      options.servername = target.servername ?? target.host;
-      if (target.ca !== void 0) {
-        options.ca = [...target.ca];
+function parseRcRequestBody(kind, body) {
+  if (kind === "heartbeat") {
+    return { controlRequests: [], answeredRequestIds: [], idleSeconds: finiteNumber(parseJsonObject(body), "idle_seconds"), workerStatus: void 0 };
+  }
+  if (kind === "worker-registration") {
+    return { controlRequests: [], answeredRequestIds: [], idleSeconds: void 0, workerStatus: nonEmptyString(parseJsonObject(body), "status") };
+  }
+  const controlRequests = [];
+  const answeredRequestIds = [];
+  for (const payload of payloadEventsOf(body)) {
+    const pending = pendingOfControlRequestPayload(payload);
+    if (pending !== void 0) {
+      controlRequests.push({ requestId: pending.requestId, type: pending.type, summary: pending.summary });
+      continue;
+    }
+    answeredRequestIds.push(...answeredRequestIdsOfControlResponsePayload(payload));
+  }
+  return { controlRequests, answeredRequestIds, idleSeconds: void 0, workerStatus: void 0 };
+}
+function createRcSessionTracker(deps) {
+  const entries = /* @__PURE__ */ new Map();
+  const expire = (id) => {
+    entries.delete(id);
+  };
+  const expirePendings = (entry, now) => {
+    for (const [requestId, pending] of entry.pending) {
+      if (now - pending.observedAt >= RC_PENDING_DEADLINE_MS) {
+        entry.pending.delete(requestId);
       }
-      if (target.rejectUnauthorized !== void 0) {
-        options.rejectUnauthorized = target.rejectUnauthorized;
+    }
+  };
+  const sweep = () => {
+    for (const [id, entry] of entries) {
+      if (deps.now() - entry.lastSeenAt >= deps.idleMs) {
+        expire(id);
+        continue;
       }
-      const request4 = https.request(options, (response) => {
-        const chunks = [];
-        response.on("data", (chunk) => {
-          chunks.push(chunk);
-        });
-        response.on("end", () => {
-          resolve({ status: response.statusCode ?? HTTP_BAD_GATEWAY, body: Buffer.concat(chunks).toString("utf8") });
-        });
-      });
-      request4.once("error", reject);
-      request4.end(body);
-    })
+      expirePendings(entry, deps.now());
+    }
   };
-}
-function realConnectEffects() {
-  const plainAgent = new ExemptHttpAgent();
-  const tlsAgent = new ExemptTlsAgent();
-  const listenOnce = async (port, onSocket) => await new Promise((resolve, reject) => {
-    const accepted = /* @__PURE__ */ new Set();
-    const server = net2.createServer((socket) => {
-      accepted.add(socket);
-      socket.on("close", () => {
-        accepted.delete(socket);
-      });
-      onSocket(socket);
-    });
-    server.once("error", reject);
-    server.listen(port, "127.0.0.1", () => {
-      const address = server.address();
-      const bound = typeof address === "object" && address !== null ? address.port : 0;
-      if (bound === 0) {
-        reject(new Error("could not bind a loopback port"));
-        return;
-      }
-      resolve({
-        port: bound,
-        close: async () => {
-          await new Promise((closeResolve) => {
-            server.close(() => {
-              closeResolve(void 0);
-            });
-            for (const socket of accepted) {
-              socket.destroy();
-            }
-          });
-        }
-      });
-    });
-  });
-  return {
-    listenLoopback: async (preferredPort, onSocket) => {
-      if (preferredPort !== void 0) {
-        try {
-          return await listenOnce(preferredPort, onSocket);
-        } catch {
-        }
+  const timer = setInterval(sweep, deps.idleMs);
+  timer.unref();
+  const birth = (id, facts) => {
+    const record = { id, createdAt: deps.now(), lastSeenAt: deps.now(), ...facts, pending: /* @__PURE__ */ new Map(), workerState: void 0, workerIdleSeconds: void 0, sequenceNum: void 0 };
+    entries.set(id, record);
+    return record;
+  };
+  const observeExchange = (request4) => {
+    const method = (request4.method ?? "").toUpperCase();
+    const path29 = new URL(request4.url ?? "/", "http://127.0.0.1").pathname;
+    if (!path29.startsWith(RC_SESSIONS_PATH_PREFIX)) {
+      return void 0;
+    }
+    const tail = path29.slice(RC_SESSIONS_PATH_PREFIX.length);
+    const facts = {
+      oauthAuthorization: oauthAuthorizationOf(request4.headers),
+      anthropicVersion: singleHeader(request4.headers, "anthropic-version"),
+      anthropicClientPlatform: singleHeader(request4.headers, "anthropic-client-platform")
+    };
+    if (tail === "") {
+      if (method !== "POST") {
+        return void 0;
       }
-      return await listenOnce(0, onSocket);
-    },
-    createTlsAcceptor: (leaf, onSecure, alpnProtocols) => {
-      let pendingContext = "";
-      const server = tls.createServer(
-        { key: leaf.keyPem, cert: leaf.certPem, ...alpnProtocols === void 0 ? {} : { ALPNProtocols: [...alpnProtocols] } },
-        (secure) => {
-          onSecure(secure, pendingContext);
-        }
-      );
-      server.on("clientError", (_error, socket) => {
-        socket.destroy();
-      });
+      let accepted2 = false;
+      let buffered2 = 0;
+      let body = "";
       return {
-        // tls.Server is a net.Server whose connection listener wraps the raw socket in the TLS handshake, and emitting the event by hand is what runs that listener on a socket this process already owns (the CONNECT half of the connection) rather than one the server accepted itself.
-        accept: (socket, context) => {
-          pendingContext = context;
-          server.emit("connection", socket);
+        onResponse: (status) => {
+          accepted2 = isSuccessful(status);
         },
-        close: () => {
-          server.close();
-        }
-      };
-    },
-    createSniTlsAcceptor: (hosts, leafFor, onSecure) => {
-      const contexts = new Map(
-        hosts.map((host) => {
-          const leaf = leafFor(host);
-          return [host, tls.createSecureContext({ key: leaf.keyPem, cert: leaf.certPem })];
-        })
-      );
-      const server = tls.createServer(
-        {
-          // No default key or cert exists, so the SNI selection is the only source of credentials: an unserved name fails its handshake here, and a client that sent no SNI at all never reaches the selection and fails for want of any certificate, which is exactly the fail-closed shape this surface wants.
-          SNICallback: (servername, callback) => {
-            const context = contexts.get(servername);
-            callback(context === void 0 ? new Error(`the transparent surface serves no host named ${servername}`) : null, context);
+        onBodyChunk: (chunk) => {
+          if (!accepted2 || buffered2 >= RC_CREATE_RESPONSE_CAP_BYTES) {
+            return;
           }
+          const text = Buffer.from(chunk).toString("utf8");
+          body = body + text.slice(0, RC_CREATE_RESPONSE_CAP_BYTES - buffered2);
+          buffered2 = body.length;
         },
-        (secure) => {
-          onSecure(secure, typeof secure.servername === "string" ? secure.servername : "");
-        }
-      );
-      server.on("clientError", (_error, socket) => {
-        socket.destroy();
-      });
-      return {
-        // The same hand-off the single-leaf acceptor uses: emitting the connection event runs the TLS server's own connection listener on a socket this process already owns (the redirect half of the connection) rather than one the server accepted itself.
-        accept: (socket) => {
-          server.emit("connection", socket);
-        },
-        close: () => {
-          server.close();
+        onEnd: () => {
+          if (!accepted2) {
+            return;
+          }
+          const id2 = sessionCreateId(body);
+          if (id2 === void 0) {
+            return;
+          }
+          birth(id2, facts);
         }
       };
-    },
-    createHttpSession: (handler, onUpgrade) => {
-      const server = http.createServer(handler);
-      server.on("clientError", (_error, socket) => {
-        socket.destroy();
-      });
-      if (onUpgrade !== void 0) {
-        server.on("upgrade", (request4, socket, head) => {
-          onUpgrade(request4, socket, head);
-        });
+    }
+    const rest = tail.slice(1);
+    const [id] = rest.split("/");
+    if (id?.startsWith(RC_SESSION_ID_PREFIX) !== true) {
+      return void 0;
+    }
+    const entry = entries.get(id) ?? birth(id, facts);
+    entry.lastSeenAt = deps.now();
+    entry.oauthAuthorization = facts.oauthAuthorization ?? entry.oauthAuthorization;
+    entry.anthropicVersion = facts.anthropicVersion ?? entry.anthropicVersion;
+    entry.anthropicClientPlatform = facts.anthropicClientPlatform ?? entry.anthropicClientPlatform;
+    const bodyKind = method === "POST" && rest === `${id}/worker/events` ? "worker-events" : method === "POST" && rest === `${id}/events` ? "client-events" : method === "POST" && rest === `${id}/worker/heartbeat` ? "heartbeat" : method === "PUT" && rest === `${id}/worker` ? "worker-registration" : void 0;
+    let chunks = [];
+    let buffered = 0;
+    let oversized = false;
+    let requestEnded = false;
+    let accepted;
+    let filed = false;
+    const file = () => {
+      if (filed || accepted !== true || !requestEnded || bodyKind === void 0) {
+        return;
       }
-      return {
-        serve: (socket) => {
-          server.emit("connection", socket);
+      filed = true;
+      const factsOfBody = oversized ? void 0 : parseRcRequestBody(bodyKind, Buffer.concat(chunks).toString("utf8"));
+      chunks = [];
+      const entryNow = entries.get(id);
+      if (entryNow === void 0 || factsOfBody === void 0) {
+        return;
+      }
+      const now = deps.now();
+      for (const controlRequest of factsOfBody.controlRequests) {
+        entryNow.pending.set(controlRequest.requestId, { sessionId: id, ...controlRequest, observedAt: now });
+      }
+      for (const requestId of factsOfBody.answeredRequestIds) {
+        entryNow.pending.delete(requestId);
+      }
+      if (factsOfBody.idleSeconds !== void 0) {
+        entryNow.workerIdleSeconds = { value: factsOfBody.idleSeconds, observedAt: now };
+      }
+      if (factsOfBody.workerStatus !== void 0) {
+        entryNow.workerState = { value: factsOfBody.workerStatus, observedAt: now };
+      }
+    };
+    const archiving = method === "POST" && rest === `${id}/archive`;
+    return {
+      ...bodyKind === void 0 ? {} : {
+        onRequestChunk: (chunk) => {
+          if (oversized) {
+            return;
+          }
+          chunks.push(Buffer.from(chunk));
+          buffered += chunk.length;
+          if (buffered > RC_REQUEST_PARSE_CAP_BYTES) {
+            oversized = true;
+            chunks = [];
+          }
         },
-        close: () => {
-          server.close();
-          server.closeAllConnections();
+        onRequestEnd: () => {
+          requestEnded = true;
+          file();
         }
-      };
-    },
-    connectTlsUpstream: async (host, port, clientAlpn) => {
-      const dialled = await reservedDial({ host, port });
-      if (dialled.error !== null) {
-        throw dialled.error;
+      },
+      onResponse: (status, headers) => {
+        if (singleHeader(headers, CONFLICT_REASON_HEADER) !== void 0 || archiving && isSuccessful(status)) {
+          expire(id);
+          return;
+        }
+        accepted = isSuccessful(status);
+        file();
+      },
+      onBodyChunk: () => {
+      },
+      onEnd: () => {
       }
-      return await new Promise((resolve, reject) => {
-        const secure = tls.connect({ socket: dialled.socket, servername: host, ...clientAlpn === void 0 ? {} : { ALPNProtocols: [clientAlpn] } });
-        secure.once("secureConnect", () => {
-          resolve(secure);
-        });
-        secure.once("error", reject);
-      });
+    };
+  };
+  const summaryOf = ({ id, createdAt, lastSeenAt }) => ({ id, createdAt, lastSeenAt });
+  const pendingSummaryOf = ({ sessionId, requestId, type, summary, observedAt }) => ({ sessionId, requestId, type, summary, observedAt });
+  const sortedEntries = () => [...entries.values()].sort((left, right) => left.createdAt - right.createdAt || (left.id < right.id ? -1 : 1));
+  const pendingSorted = (entry) => [...entry.pending.values()].sort((left, right) => left.observedAt - right.observedAt || (left.requestId < right.requestId ? -1 : 1)).map(pendingSummaryOf);
+  return {
+    observeExchange,
+    list: () => {
+      sweep();
+      return sortedEntries().map(summaryOf);
     },
-    connectTcp: async (host, port) => await new Promise((resolve, reject) => {
-      const socket = net2.connect({ host, port });
-      socket.once("connect", () => {
-        resolve(socket);
-      });
-      socket.once("error", reject);
-    }),
-    forwardHttp: (target, request4, response, observer) => {
-      const headers = forwardableHeaders(request4.headers);
-      const options = {
-        host: target.host,
-        port: target.port,
-        lookup: realAddressLookup,
-        method: request4.method,
-        path: request4.url,
-        headers,
-        agent: target.tls ? tlsAgent : plainAgent
-      };
-      if (target.tls) {
-        options.servername = target.servername ?? target.host;
-        if (target.ca !== void 0) {
-          options.ca = [...target.ca];
-        }
-        if (target.rejectUnauthorized !== void 0) {
-          options.rejectUnauthorized = target.rejectUnauthorized;
-        }
+    statusOf: (sessionId) => {
+      sweep();
+      return sortedEntries().filter((entry) => sessionId === void 0 || entry.id === sessionId).map((entry) => ({ ...summaryOf(entry), workerState: entry.workerState, workerIdleSeconds: entry.workerIdleSeconds, pending: pendingSorted(entry) }));
+    },
+    pendingOf: (sessionId) => {
+      sweep();
+      return sortedEntries().filter((entry) => sessionId === void 0 || entry.id === sessionId).flatMap((entry) => pendingSorted(entry));
+    },
+    credentialOf: (sessionId) => {
+      const entry = entries.get(sessionId);
+      return entry === void 0 ? void 0 : { authorization: entry.oauthAuthorization, anthropicVersion: entry.anthropicVersion, anthropicClientPlatform: entry.anthropicClientPlatform };
+    },
+    noteSequenceNums: (sessionId, sequenceNums) => {
+      const entry = entries.get(sessionId);
+      if (entry === void 0) {
+        return;
       }
-      const onUpstreamResponse = (upstreamResponse) => {
-        observer?.onResponse(upstreamResponse.statusCode ?? HTTP_BAD_GATEWAY, upstreamResponse.headers);
-        response.writeHead(upstreamResponse.statusCode ?? HTTP_BAD_GATEWAY, forwardableHeaders(upstreamResponse.headers));
-        response.flushHeaders();
-        if (observer !== void 0) {
-          upstreamResponse.on("data", (chunk) => {
-            observer.onResponseChunk(chunk);
-          });
-        }
-        upstreamResponse.pipe(response);
-      };
-      const upstream = target.tls ? https.request(options, onUpstreamResponse) : http.request(options, onUpstreamResponse);
-      upstream.on("error", (error) => {
-        if (response.headersSent) {
-          response.destroy(error);
-          return;
+      for (const sequenceNum of sequenceNums) {
+        entry.sequenceNum = entry.sequenceNum === void 0 || sequenceNum > entry.sequenceNum ? sequenceNum : entry.sequenceNum;
+      }
+    },
+    sequenceNumOf: (sessionId) => entries.get(sessionId)?.sequenceNum,
+    fileStreamEvent: (sessionId, event) => {
+      const entry = entries.get(sessionId);
+      if (entry === void 0) {
+        return;
+      }
+      entry.sequenceNum = entry.sequenceNum === void 0 || event.sequence_num > entry.sequenceNum ? event.sequence_num : entry.sequenceNum;
+      if (!isRecord2(event.payload)) {
+        return;
+      }
+      const pending = pendingOfControlRequestPayload(event.payload);
+      if (pending !== void 0) {
+        if (event.source === RC_STREAM_WORKER_SOURCE) {
+          entry.pending.set(pending.requestId, { sessionId, ...pending, observedAt: deps.now() });
         }
-        const body = `agent-shim headroom: upstream unreachable (${error.message})`;
-        response.writeHead(HTTP_BAD_GATEWAY, { "content-type": "text/plain", "content-length": String(body.length) });
-        response.end(body);
-      });
-      if (observer !== void 0) {
-        request4.on("data", (chunk) => {
-          observer.onRequestChunk(chunk);
+        return;
+      }
+      for (const requestId of answeredRequestIdsOfControlResponsePayload(event.payload)) {
+        entry.pending.delete(requestId);
+      }
+    },
+    completePending: (sessionId, requestId) => {
+      entries.get(sessionId)?.pending.delete(requestId);
+    },
+    close: () => {
+      clearInterval(timer);
+    }
+  };
+}
+function observingRoutedRoute(route, tracker, hooks) {
+  return {
+    ...route,
+    serve: async (request4, response) => {
+      const observed = tracker.observeExchange({ method: request4.method, url: request4.url, headers: request4.headers });
+      if (observed?.onRequestChunk !== void 0) {
+        request4.body.on("data", (chunk) => {
+          observed.onRequestChunk?.(chunk);
         });
-        if (observer.onRequestEnd !== void 0) {
-          request4.on("end", () => {
-            observer.onRequestEnd?.();
-          });
-        }
-        response.on("close", () => {
-          observer.onEnd();
+        request4.body.on("end", () => {
+          observed.onRequestEnd?.();
         });
       }
-      request4.pipe(upstream);
-      request4.socket.setNoDelay(true);
-      upstream.on("socket", (socket) => {
-        socket.setNoDelay(true);
-      });
+      await route.serve(request4, observed === void 0 ? response : teeRoutedResponse(response, observed, hooks?.onExchangeSettled));
     }
   };
 }
-
-// src/codex/http.ts
-var HTTP_STATUS = {
-  ok: 200,
-  badRequest: 400,
-  unauthorized: 401,
-  forbidden: 403,
-  notFound: 404,
-  methodNotAllowed: 405,
-  payloadTooLarge: 413,
-  tooManyRequests: 429,
-  /** Not sent to anyone: the client is gone. Recorded for a response abandoned because the client disconnected, following the convention nginx uses for the same case. */
-  clientClosedRequest: 499,
-  internalServerError: 500,
-  badGateway: 502
-};
-
-// src/frontdoor/rcSessions.ts
-var RC_SESSIONS_PATH_PREFIX = "/v1/code/sessions";
-var RC_SESSION_ID_PREFIX = "cse_";
-var RC_IDLE_EXPIRY_MS = 45e3;
-var RC_CREATE_RESPONSE_CAP_BYTES = 8192;
-var CONFLICT_REASON_HEADER = "x-ccr-conflict-reason";
-var RC_PENDING_DEADLINE_MS = 14e3;
-var RC_REQUEST_PARSE_CAP_BYTES = 262144;
-var RC_PENDING_SUMMARY_EXCERPT_CHARS = 300;
-var SUCCESS_STATUS_MAX_EXCLUSIVE = 300;
-function isSuccessful(status) {
-  return status >= HTTP_STATUS.ok && status < SUCCESS_STATUS_MAX_EXCLUSIVE;
+function teeRoutedResponse(response, observer, onSettled) {
+  return {
+    get headersSent() {
+      return response.headersSent;
+    },
+    start: (status, headers) => {
+      observer.onResponse(status, headers);
+      response.start(status, headers);
+    },
+    flush: () => {
+      response.flush();
+    },
+    write: async (chunk) => {
+      observer.onBodyChunk(typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk);
+      await response.write(chunk);
+    },
+    end: () => {
+      response.end();
+      observer.onEnd();
+      onSettled?.();
+    },
+    destroy: () => {
+      response.destroy();
+      observer.onEnd();
+      onSettled?.();
+    }
+  };
 }
-function singleHeader(headers, name) {
-  const value = headers[name];
-  return typeof value === "string" ? value : void 0;
+function rcObserverAsPassthrough(observer) {
+  return {
+    onRequestChunk: (chunk) => {
+      observer.onRequestChunk?.(chunk);
+    },
+    ...observer.onRequestEnd === void 0 ? {} : {
+      onRequestEnd: () => {
+        observer.onRequestEnd?.();
+      }
+    },
+    onResponse: (status, headers) => {
+      observer.onResponse(status, headers);
+    },
+    onResponseChunk: (chunk) => {
+      observer.onBodyChunk(chunk);
+    },
+    onEnd: () => {
+      observer.onEnd();
+    }
+  };
 }
-var OAUTH_AUTHORIZATION_PREFIX = "Bearer sk-ant-oat";
-function oauthAuthorizationOf(headers) {
-  const value = singleHeader(headers, "authorization");
-  return value?.startsWith(OAUTH_AUTHORIZATION_PREFIX) === true ? value : void 0;
+function buildRcUserMessagePayload(uuid, sessionId, text) {
+  return {
+    type: "user",
+    uuid,
+    session_id: sessionId,
+    parent_tool_use_id: null,
+    message: { role: "user", content: text }
+  };
 }
-function sessionCreateId(body) {
+function buildRcEventWriteBody(payload) {
+  return { events: [{ payload }] };
+}
+function sequenceNumsOf(body) {
   let parsed;
   try {
     parsed = JSON.parse(body);
   } catch {
     return void 0;
   }
-  if (typeof parsed !== "object" || parsed === null || !("session" in parsed)) {
+  if (typeof parsed !== "object" || parsed === null || !("results" in parsed) || !Array.isArray(parsed.results)) {
     return void 0;
   }
-  const session = parsed.session;
-  if (typeof session !== "object" || session === null || !("id" in session)) {
-    return void 0;
+  const sequenceNums = [];
+  const results = parsed.results;
+  for (const result of results) {
+    if (typeof result !== "object" || result === null || !("sequence_num" in result)) {
+      return void 0;
+    }
+    const sequenceNum = result.sequence_num;
+    if (typeof sequenceNum === "number") {
+      sequenceNums.push(sequenceNum);
+    } else if (typeof sequenceNum === "string" && /^[0-9]+$/.test(sequenceNum)) {
+      sequenceNums.push(Number(sequenceNum));
+    } else {
+      return void 0;
+    }
   }
-  const id = session.id;
-  return typeof id === "string" && id.startsWith(RC_SESSION_ID_PREFIX) ? id : void 0;
-}
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
+  return sequenceNums.length === 0 ? void 0 : sequenceNums;
 }
-function parseJsonObject(body) {
-  let parsed;
-  try {
-    parsed = JSON.parse(body);
-  } catch {
-    return void 0;
+function rcEventWriteResultFromAnswer(answer) {
+  if (!isSuccessful(answer.status)) {
+    if (answer.status === HTTP_STATUS.unauthorized) {
+      return { ok: false, message: `the API refused the observed Authorization bearer for this session (HTTP 401): the bearer went stale after the door last saw the session's traffic. The session's own client refreshes it on its next call, which the door will observe, so retry once Remote Control has been active again. API answer: ${answer.body}` };
+    }
+    return { ok: false, message: `the API answered HTTP ${String(answer.status)} to the injected event: ${answer.body}` };
   }
-  return isRecord2(parsed) ? parsed : void 0;
-}
-function nonEmptyString(record, field) {
-  const value = record === void 0 ? void 0 : record[field];
-  return typeof value === "string" && value !== "" ? value : void 0;
+  const sequenceNums = sequenceNumsOf(answer.body);
+  if (sequenceNums === void 0) {
+    return { ok: false, message: `the API accepted the injected event but its answer named no results[].sequence_num, so delivery cannot be confirmed: ${answer.body}` };
+  }
+  return { ok: true, sequenceNums };
 }
-function finiteNumber(record, field) {
-  const value = record === void 0 ? void 0 : record[field];
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+function noOAuthCredentialResult(sessionId) {
+  return { ok: false, message: `no claude.ai OAuth bearer has been observed for session ${sessionId}: only worker calls crossed this door, and the worker JWT they carry is answered 401 on the client half. Reconnect Remote Control through this door and the create's own bearer will be observed` };
 }
-function excerpt(text) {
-  return text.length <= RC_PENDING_SUMMARY_EXCERPT_CHARS ? text : `${text.slice(0, RC_PENDING_SUMMARY_EXCERPT_CHARS)}...`;
+function rcSessionNotObservedMessage(sessionId) {
+  return `the front door has not observed Remote Control session ${sessionId}: it may never have passed through this door, or it ended or expired (an entry lives only a bounded idle period past its last observed traffic)`;
 }
-function payloadEventsOf(body) {
-  const parsed = parseJsonObject(body);
-  const events = parsed === void 0 ? void 0 : parsed.events;
-  if (!Array.isArray(events)) {
-    return [];
-  }
-  const payloads = [];
-  for (const event of events) {
-    if (!isRecord2(event)) {
-      continue;
-    }
-    const payload = event.payload;
-    if (!isRecord2(payload)) {
-      continue;
-    }
-    payloads.push(payload);
+function rcWriteHeaders(credential) {
+  const headers = { "content-type": "application/json" };
+  if (credential.authorization !== void 0) {
+    headers.authorization = credential.authorization;
   }
-  return payloads;
+  if (credential.anthropicVersion !== void 0) {
+    headers["anthropic-version"] = credential.anthropicVersion;
+  }
+  if (credential.anthropicClientPlatform !== void 0) {
+    headers["anthropic-client-platform"] = credential.anthropicClientPlatform;
+  }
+  return headers;
 }
-function pendingOfControlRequestPayload(payload) {
-  if (payload.type !== "control_request") {
-    return void 0;
+async function injectRcUserMessage(deps, sessionId, text) {
+  const credential = deps.credentialOf(sessionId);
+  if (credential === void 0) {
+    return { ok: false, message: rcSessionNotObservedMessage(sessionId) };
   }
-  const requestId = nonEmptyString(payload, "request_id") ?? nonEmptyString(payload, "uuid");
-  if (requestId === void 0) {
-    return void 0;
+  if (credential.authorization === void 0) {
+    return noOAuthCredentialResult(sessionId);
   }
-  const request4 = isRecord2(payload.request) ? payload.request : void 0;
-  const subtype = nonEmptyString(request4, "subtype");
-  const type = subtype ?? "control_request";
-  let summary = "";
-  if (subtype === "can_use_tool") {
-    const toolName = nonEmptyString(request4, "tool_name") ?? "unknown tool";
-    const input = request4 === void 0 ? void 0 : request4.input;
-    summary = input === void 0 ? toolName : `${toolName} ${excerpt(JSON.stringify(input))}`;
-  } else if (request4 !== void 0) {
-    summary = excerpt(JSON.stringify(request4));
+  const body = JSON.stringify(buildRcEventWriteBody(buildRcUserMessagePayload(deps.newUuid(), sessionId, text)));
+  let answer;
+  try {
+    answer = await deps.dial.writeEvents(sessionId, rcWriteHeaders(credential), body);
+  } catch (error) {
+    return { ok: false, message: `the door could not reach the API host to inject into session ${sessionId}: ${error instanceof Error ? error.message : String(error)}` };
   }
-  return { requestId, type, summary };
+  const result = rcEventWriteResultFromAnswer(answer);
+  if (result.ok) {
+    deps.noteSequenceNums(sessionId, result.sequenceNums);
+  }
+  return result;
 }
-function answeredRequestIdsOfControlResponsePayload(payload) {
-  if (payload.type !== "control_response") {
-    return [];
+function buildRcControlResponsePayload(requestId, decision) {
+  const result = decision.approve ? { behavior: "allow" } : { behavior: "deny", message: decision.message ?? "" };
+  return { type: "control_response", response: { subtype: "success", request_id: requestId, response: result } };
+}
+var RC_PERMISSION_MODES = ["default", "acceptEdits", "bypassPermissions", "plan", "dontAsk", "auto"];
+function isRcPermissionMode(value) {
+  return RC_PERMISSION_MODES.some((mode) => mode === value);
+}
+function buildRcInterruptPayload(requestId) {
+  return { type: "control_request", request_id: requestId, request: { subtype: "interrupt" } };
+}
+function buildRcSetModelPayload(requestId, model) {
+  return { type: "control_request", request_id: requestId, request: { subtype: "set_model", model } };
+}
+function buildRcSetPermissionModePayload(requestId, mode) {
+  return { type: "control_request", request_id: requestId, request: { subtype: "set_permission_mode", mode } };
+}
+async function answerRcControlRequest(deps, sessionId, requestId, decision) {
+  const credential = deps.credentialOf(sessionId);
+  if (credential === void 0) {
+    return { ok: false, message: rcSessionNotObservedMessage(sessionId) };
   }
-  const response = isRecord2(payload.response) ? payload.response : void 0;
-  const id = nonEmptyString(response, "request_id") ?? nonEmptyString(payload, "request_id") ?? nonEmptyString(payload, "uuid");
-  return id === void 0 ? [] : [id];
+  if (credential.authorization === void 0) {
+    return noOAuthCredentialResult(sessionId);
+  }
+  if (!deps.pendingOf(sessionId).some((pending) => pending.requestId === requestId)) {
+    return { ok: false, message: `the front door has not observed control request ${requestId} pending on session ${sessionId}: it was answered already (by this door or by an attached client), it passed its answer deadline (the protocol's permission round-trip bound), or it never passed through this door` };
+  }
+  const body = JSON.stringify(buildRcEventWriteBody(buildRcControlResponsePayload(requestId, decision)));
+  let answer;
+  try {
+    answer = await deps.dial.writeEvents(sessionId, rcWriteHeaders(credential), body);
+  } catch (error) {
+    return { ok: false, message: `the door could not reach the API host to answer on session ${sessionId}: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  const result = rcEventWriteResultFromAnswer(answer);
+  if (result.ok) {
+    deps.completePending(sessionId, requestId);
+    deps.noteSequenceNums(sessionId, result.sequenceNums);
+  }
+  return result;
 }
-function parseRcRequestBody(kind, body) {
-  if (kind === "heartbeat") {
-    return { controlRequests: [], answeredRequestIds: [], idleSeconds: finiteNumber(parseJsonObject(body), "idle_seconds"), workerStatus: void 0 };
+async function interruptRcSession(deps, sessionId) {
+  const credential = deps.credentialOf(sessionId);
+  if (credential === void 0) {
+    return { ok: false, message: rcSessionNotObservedMessage(sessionId) };
   }
-  if (kind === "worker-registration") {
-    return { controlRequests: [], answeredRequestIds: [], idleSeconds: void 0, workerStatus: nonEmptyString(parseJsonObject(body), "status") };
+  if (credential.authorization === void 0) {
+    return noOAuthCredentialResult(sessionId);
   }
-  const controlRequests = [];
-  const answeredRequestIds = [];
-  for (const payload of payloadEventsOf(body)) {
-    const pending = pendingOfControlRequestPayload(payload);
-    if (pending !== void 0) {
-      controlRequests.push({ requestId: pending.requestId, type: pending.type, summary: pending.summary });
-      continue;
-    }
-    answeredRequestIds.push(...answeredRequestIdsOfControlResponsePayload(payload));
+  const body = JSON.stringify(buildRcEventWriteBody(buildRcInterruptPayload(deps.newUuid())));
+  let answer;
+  try {
+    answer = await deps.dial.writeEvents(sessionId, rcWriteHeaders(credential), body);
+  } catch (error) {
+    return { ok: false, message: `the door could not reach the API host to interrupt session ${sessionId}: ${error instanceof Error ? error.message : String(error)}` };
   }
-  return { controlRequests, answeredRequestIds, idleSeconds: void 0, workerStatus: void 0 };
+  const result = rcEventWriteResultFromAnswer(answer);
+  if (result.ok) {
+    deps.noteSequenceNums(sessionId, result.sequenceNums);
+  }
+  return result;
 }
-function createRcSessionTracker(deps) {
-  const entries = /* @__PURE__ */ new Map();
-  const expire = (id) => {
-    entries.delete(id);
-  };
-  const expirePendings = (entry, now) => {
-    for (const [requestId, pending] of entry.pending) {
-      if (now - pending.observedAt >= RC_PENDING_DEADLINE_MS) {
-        entry.pending.delete(requestId);
+async function setRcSessionModel(deps, sessionId, model) {
+  if (model === "") {
+    return { ok: false, message: "a set-model write needs a non-empty model id: the SDK's own field treats an omitted or null value as a reset to the session default, which this operation never sends, and an empty string is neither" };
+  }
+  const credential = deps.credentialOf(sessionId);
+  if (credential === void 0) {
+    return { ok: false, message: rcSessionNotObservedMessage(sessionId) };
+  }
+  if (credential.authorization === void 0) {
+    return noOAuthCredentialResult(sessionId);
+  }
+  const body = JSON.stringify(buildRcEventWriteBody(buildRcSetModelPayload(deps.newUuid(), model)));
+  let answer;
+  try {
+    answer = await deps.dial.writeEvents(sessionId, rcWriteHeaders(credential), body);
+  } catch (error) {
+    return { ok: false, message: `the door could not reach the API host to set the model on session ${sessionId}: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  const result = rcEventWriteResultFromAnswer(answer);
+  if (result.ok) {
+    deps.noteSequenceNums(sessionId, result.sequenceNums);
+  }
+  return result;
+}
+async function setRcSessionPermissionMode(deps, sessionId, mode) {
+  const credential = deps.credentialOf(sessionId);
+  if (credential === void 0) {
+    return { ok: false, message: rcSessionNotObservedMessage(sessionId) };
+  }
+  if (credential.authorization === void 0) {
+    return noOAuthCredentialResult(sessionId);
+  }
+  const body = JSON.stringify(buildRcEventWriteBody(buildRcSetPermissionModePayload(deps.newUuid(), mode)));
+  let answer;
+  try {
+    answer = await deps.dial.writeEvents(sessionId, rcWriteHeaders(credential), body);
+  } catch (error) {
+    return { ok: false, message: `the door could not reach the API host to set the permission mode on session ${sessionId}: ${error instanceof Error ? error.message : String(error)}` };
+  }
+  const result = rcEventWriteResultFromAnswer(answer);
+  if (result.ok) {
+    deps.noteSequenceNums(sessionId, result.sequenceNums);
+  }
+  return result;
+}
+
+// src/frontdoor/rcControl.ts
+var RC_PERMISSION_MODE_LIST = RC_PERMISSION_MODES.join(", ");
+var CONTROL_PATH_PREFIX = "/__agent-shim/rc";
+var CONTROL_BODY_CAP_BYTES = 10485760;
+function answerJson(response, status, body) {
+  const text = JSON.stringify(body);
+  response.writeHead(status, { "content-type": "application/json", "content-length": String(Buffer.byteLength(text, "utf8")) });
+  response.end(text);
+}
+async function readBody(request4) {
+  return await new Promise((resolve, reject) => {
+    const chunks = [];
+    let total = 0;
+    request4.on("data", (chunk) => {
+      total += chunk.length;
+      if (total > CONTROL_BODY_CAP_BYTES) {
+        request4.destroy();
+        reject(new Error("too large"));
+        return;
       }
+      chunks.push(chunk);
+    });
+    request4.on("end", () => {
+      resolve(Buffer.concat(chunks).toString("utf8"));
+    });
+    request4.on("error", () => {
+      reject(new Error("the request body ended early"));
+    });
+  });
+}
+function createRcControlHandler(deps) {
+  const sessionsPath = `${CONTROL_PATH_PREFIX}/sessions`;
+  const statusPath = `${CONTROL_PATH_PREFIX}/status`;
+  const pendingPath = `${CONTROL_PATH_PREFIX}/pending`;
+  const injectPath = `${CONTROL_PATH_PREFIX}/inject`;
+  const answerPath = `${CONTROL_PATH_PREFIX}/answer`;
+  const interruptPath = `${CONTROL_PATH_PREFIX}/interrupt`;
+  const setModelPath = `${CONTROL_PATH_PREFIX}/set-model`;
+  const setPermissionModePath = `${CONTROL_PATH_PREFIX}/set-permission-mode`;
+  return (request4, response) => {
+    const presented = request4.headers.authorization;
+    const bearerPrefix = "bearer ".length;
+    const token = typeof presented === "string" && presented.slice(0, bearerPrefix).toLowerCase() === "bearer " ? presented.slice(bearerPrefix) : void 0;
+    if (token === void 0 || !isLiveCapability(token, [deps.expectedToken])) {
+      answerJson(response, HTTP_STATUS.unauthorized, { error: "the front door's control routes demand this generation's control token as a Bearer credential" });
+      return;
     }
-  };
-  const sweep = () => {
-    for (const [id, entry] of entries) {
-      if (deps.now() - entry.lastSeenAt >= deps.idleMs) {
-        expire(id);
-        continue;
+    const url = new URL(request4.url ?? "/", "http://127.0.0.1");
+    const handle = async () => {
+      if (url.pathname === sessionsPath) {
+        if (request4.method !== "GET") {
+          answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the session list is a GET" });
+          return;
+        }
+        answerJson(response, HTTP_STATUS.ok, { sessions: deps.list() });
+        return;
       }
-      expirePendings(entry, deps.now());
-    }
-  };
-  const timer = setInterval(sweep, deps.idleMs);
-  timer.unref();
-  const birth = (id, facts) => {
-    const record = { id, createdAt: deps.now(), lastSeenAt: deps.now(), ...facts, pending: /* @__PURE__ */ new Map(), workerState: void 0, workerIdleSeconds: void 0 };
-    entries.set(id, record);
-    return record;
-  };
-  const observeExchange = (request4) => {
-    const method = (request4.method ?? "").toUpperCase();
-    const path29 = new URL(request4.url ?? "/", "http://127.0.0.1").pathname;
-    if (!path29.startsWith(RC_SESSIONS_PATH_PREFIX)) {
-      return void 0;
-    }
-    const tail = path29.slice(RC_SESSIONS_PATH_PREFIX.length);
-    const facts = {
-      oauthAuthorization: oauthAuthorizationOf(request4.headers),
-      anthropicVersion: singleHeader(request4.headers, "anthropic-version"),
-      anthropicClientPlatform: singleHeader(request4.headers, "anthropic-client-platform")
-    };
-    if (tail === "") {
-      if (method !== "POST") {
-        return void 0;
-      }
-      let accepted2 = false;
-      let buffered2 = 0;
-      let body = "";
-      return {
-        onResponse: (status) => {
-          accepted2 = isSuccessful(status);
-        },
-        onBodyChunk: (chunk) => {
-          if (!accepted2 || buffered2 >= RC_CREATE_RESPONSE_CAP_BYTES) {
-            return;
-          }
-          const text = Buffer.from(chunk).toString("utf8");
-          body = body + text.slice(0, RC_CREATE_RESPONSE_CAP_BYTES - buffered2);
-          buffered2 = body.length;
-        },
-        onEnd: () => {
-          if (!accepted2) {
-            return;
-          }
-          const id2 = sessionCreateId(body);
-          if (id2 === void 0) {
-            return;
-          }
-          birth(id2, facts);
+      if (url.pathname === statusPath || url.pathname === pendingPath) {
+        if (request4.method !== "GET") {
+          answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the status and pending reads are GETs" });
+          return;
         }
-      };
-    }
-    const rest = tail.slice(1);
-    const [id] = rest.split("/");
-    if (id?.startsWith(RC_SESSION_ID_PREFIX) !== true) {
-      return void 0;
-    }
-    const entry = entries.get(id) ?? birth(id, facts);
-    entry.lastSeenAt = deps.now();
-    entry.oauthAuthorization = facts.oauthAuthorization ?? entry.oauthAuthorization;
-    entry.anthropicVersion = facts.anthropicVersion ?? entry.anthropicVersion;
-    entry.anthropicClientPlatform = facts.anthropicClientPlatform ?? entry.anthropicClientPlatform;
-    const bodyKind = method === "POST" && rest === `${id}/worker/events` ? "worker-events" : method === "POST" && rest === `${id}/events` ? "client-events" : method === "POST" && rest === `${id}/worker/heartbeat` ? "heartbeat" : method === "PUT" && rest === `${id}/worker` ? "worker-registration" : void 0;
-    let chunks = [];
-    let buffered = 0;
-    let oversized = false;
-    let requestEnded = false;
-    let accepted;
-    let filed = false;
-    const file = () => {
-      if (filed || accepted !== true || !requestEnded || bodyKind === void 0) {
+        const session = url.searchParams.get("session") ?? void 0;
+        if (session !== void 0 && !deps.statusOf(session).some((entry) => entry.id === session)) {
+          answerJson(response, HTTP_STATUS.notFound, { error: rcSessionNotObservedMessage(session) });
+          return;
+        }
+        answerJson(response, HTTP_STATUS.ok, url.pathname === statusPath ? { statuses: deps.statusOf(session) } : { pending: deps.pendingOf(session) });
         return;
       }
-      filed = true;
-      const factsOfBody = oversized ? void 0 : parseRcRequestBody(bodyKind, Buffer.concat(chunks).toString("utf8"));
-      chunks = [];
-      const entryNow = entries.get(id);
-      if (entryNow === void 0 || factsOfBody === void 0) {
+      if (url.pathname === injectPath) {
+        if (request4.method !== "POST") {
+          answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the inject operation is a POST" });
+          return;
+        }
+        let parsed;
+        try {
+          parsed = JSON.parse(await readBody(request4));
+        } catch {
+          answerJson(response, HTTP_STATUS.badRequest, { error: "the inject body is not readable JSON within the control body cap" });
+          return;
+        }
+        if (typeof parsed !== "object" || parsed === null || !("session" in parsed) || !("text" in parsed) || typeof parsed.session !== "string" || typeof parsed.text !== "string" || parsed.session === "" || parsed.text === "") {
+          answerJson(response, HTTP_STATUS.badRequest, { error: "the inject body must be JSON naming a non-empty session id and text" });
+          return;
+        }
+        const result = await deps.inject(parsed.session, parsed.text);
+        if (result.ok) {
+          answerJson(response, HTTP_STATUS.ok, { session: parsed.session, sequenceNums: result.sequenceNums });
+          return;
+        }
+        answerJson(response, HTTP_STATUS.badGateway, { error: result.message });
         return;
       }
-      const now = deps.now();
-      for (const controlRequest of factsOfBody.controlRequests) {
-        entryNow.pending.set(controlRequest.requestId, { sessionId: id, ...controlRequest, observedAt: now });
-      }
-      for (const requestId of factsOfBody.answeredRequestIds) {
-        entryNow.pending.delete(requestId);
+      if (url.pathname === answerPath) {
+        if (request4.method !== "POST") {
+          answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the answer operation is a POST" });
+          return;
+        }
+        let parsed;
+        try {
+          parsed = JSON.parse(await readBody(request4));
+        } catch {
+          answerJson(response, HTTP_STATUS.badRequest, { error: "the answer body is not readable JSON within the control body cap" });
+          return;
+        }
+        if (typeof parsed !== "object" || parsed === null || !("session" in parsed) || !("request" in parsed) || !("approve" in parsed) || typeof parsed.session !== "string" || typeof parsed.request !== "string" || typeof parsed.approve !== "boolean" || parsed.session === "" || parsed.request === "") {
+          answerJson(response, HTTP_STATUS.badRequest, { error: "the answer body must be JSON naming a non-empty session id, request id, and an approve boolean" });
+          return;
+        }
+        const text = "text" in parsed && typeof parsed.text === "string" ? parsed.text : void 0;
+        if (parsed.approve && text !== void 0 && text !== "") {
+          answerJson(response, HTTP_STATUS.badRequest, { error: "an approval carries no text (the protocol's allow result has no message field); text is the denial message" });
+          return;
+        }
+        const result = await deps.answer(parsed.session, parsed.request, { approve: parsed.approve, message: parsed.approve ? void 0 : text });
+        if (result.ok) {
+          answerJson(response, HTTP_STATUS.ok, { session: parsed.session, request: parsed.request, sequenceNums: result.sequenceNums });
+          return;
+        }
+        answerJson(response, HTTP_STATUS.badGateway, { error: result.message });
+        return;
       }
-      if (factsOfBody.idleSeconds !== void 0) {
-        entryNow.workerIdleSeconds = { value: factsOfBody.idleSeconds, observedAt: now };
+      if (url.pathname === interruptPath) {
+        if (request4.method !== "POST") {
+          answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the interrupt operation is a POST" });
+          return;
+        }
+        let parsed;
+        try {
+          parsed = JSON.parse(await readBody(request4));
+        } catch {
+          answerJson(response, HTTP_STATUS.badRequest, { error: "the interrupt body is not readable JSON within the control body cap" });
+          return;
+        }
+        if (typeof parsed !== "object" || parsed === null || !("session" in parsed) || typeof parsed.session !== "string" || parsed.session === "") {
+          answerJson(response, HTTP_STATUS.badRequest, { error: "the interrupt body must be JSON naming a non-empty session id" });
+          return;
+        }
+        const result = await deps.interrupt(parsed.session);
+        if (result.ok) {
+          answerJson(response, HTTP_STATUS.ok, { session: parsed.session, sequenceNums: result.sequenceNums });
+          return;
+        }
+        answerJson(response, HTTP_STATUS.badGateway, { error: result.message });
+        return;
       }
-      if (factsOfBody.workerStatus !== void 0) {
-        entryNow.workerState = { value: factsOfBody.workerStatus, observedAt: now };
+      if (url.pathname === setModelPath) {
+        if (request4.method !== "POST") {
+          answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the set-model operation is a POST" });
+          return;
+        }
+        let parsed;
+        try {
+          parsed = JSON.parse(await readBody(request4));
+        } catch {
+          answerJson(response, HTTP_STATUS.badRequest, { error: "the set-model body is not readable JSON within the control body cap" });
+          return;
+        }
+        if (typeof parsed !== "object" || parsed === null || !("session" in parsed) || !("model" in parsed) || typeof parsed.session !== "string" || typeof parsed.model !== "string" || parsed.session === "" || parsed.model === "") {
+          answerJson(response, HTTP_STATUS.badRequest, { error: "the set-model body must be JSON naming a non-empty session id and model id" });
+          return;
+        }
+        const result = await deps.setModel(parsed.session, parsed.model);
+        if (result.ok) {
+          answerJson(response, HTTP_STATUS.ok, { session: parsed.session, model: parsed.model, sequenceNums: result.sequenceNums });
+          return;
+        }
+        answerJson(response, HTTP_STATUS.badGateway, { error: result.message });
+        return;
       }
-    };
-    const archiving = method === "POST" && rest === `${id}/archive`;
-    return {
-      ...bodyKind === void 0 ? {} : {
-        onRequestChunk: (chunk) => {
-          if (oversized) {
-            return;
-          }
-          chunks.push(Buffer.from(chunk));
-          buffered += chunk.length;
-          if (buffered > RC_REQUEST_PARSE_CAP_BYTES) {
-            oversized = true;
-            chunks = [];
-          }
-        },
-        onRequestEnd: () => {
-          requestEnded = true;
-          file();
+      if (url.pathname === setPermissionModePath) {
+        if (request4.method !== "POST") {
+          answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the set-permission-mode operation is a POST" });
+          return;
         }
-      },
-      onResponse: (status, headers) => {
-        if (singleHeader(headers, CONFLICT_REASON_HEADER) !== void 0 || archiving && isSuccessful(status)) {
-          expire(id);
+        let parsed;
+        try {
+          parsed = JSON.parse(await readBody(request4));
+        } catch {
+          answerJson(response, HTTP_STATUS.badRequest, { error: "the set-permission-mode body is not readable JSON within the control body cap" });
           return;
         }
-        accepted = isSuccessful(status);
-        file();
-      },
-      onBodyChunk: () => {
-      },
-      onEnd: () => {
+        if (typeof parsed !== "object" || parsed === null || !("session" in parsed) || !("mode" in parsed) || typeof parsed.session !== "string" || parsed.session === "" || !isRcPermissionMode(parsed.mode)) {
+          answerJson(response, HTTP_STATUS.badRequest, { error: `the set-permission-mode body must be JSON naming a non-empty session id and a mode the SDK's own type permits (${RC_PERMISSION_MODE_LIST})` });
+          return;
+        }
+        const result = await deps.setPermissionMode(parsed.session, parsed.mode);
+        if (result.ok) {
+          answerJson(response, HTTP_STATUS.ok, { session: parsed.session, mode: parsed.mode, sequenceNums: result.sequenceNums });
+          return;
+        }
+        answerJson(response, HTTP_STATUS.badGateway, { error: result.message });
+        return;
       }
+      answerJson(response, HTTP_STATUS.notFound, { error: `no such control route: ${url.pathname}` });
     };
+    handle().catch((error) => {
+      answerJson(response, HTTP_STATUS.internalServerError, { error: `the control route failed: ${error instanceof Error ? error.message : String(error)}` });
+    });
   };
-  const summaryOf = ({ id, createdAt, lastSeenAt }) => ({ id, createdAt, lastSeenAt });
-  const pendingSummaryOf = ({ sessionId, requestId, type, summary, observedAt }) => ({ sessionId, requestId, type, summary, observedAt });
-  const sortedEntries = () => [...entries.values()].sort((left, right) => left.createdAt - right.createdAt || (left.id < right.id ? -1 : 1));
-  const pendingSorted = (entry) => [...entry.pending.values()].sort((left, right) => left.observedAt - right.observedAt || (left.requestId < right.requestId ? -1 : 1)).map(pendingSummaryOf);
+}
+function realRcControlTransport(port, ca) {
   return {
-    observeExchange,
-    list: () => {
-      sweep();
-      return sortedEntries().map(summaryOf);
-    },
-    statusOf: (sessionId) => {
-      sweep();
-      return sortedEntries().filter((entry) => sessionId === void 0 || entry.id === sessionId).map((entry) => ({ ...summaryOf(entry), workerState: entry.workerState, workerIdleSeconds: entry.workerIdleSeconds, pending: pendingSorted(entry) }));
-    },
-    pendingOf: (sessionId) => {
-      sweep();
-      return sortedEntries().filter((entry) => sessionId === void 0 || entry.id === sessionId).flatMap((entry) => pendingSorted(entry));
-    },
-    credentialOf: (sessionId) => {
-      const entry = entries.get(sessionId);
-      return entry === void 0 ? void 0 : { authorization: entry.oauthAuthorization, anthropicVersion: entry.anthropicVersion, anthropicClientPlatform: entry.anthropicClientPlatform };
-    },
-    completePending: (sessionId, requestId) => {
-      entries.get(sessionId)?.pending.delete(requestId);
-    },
-    close: () => {
-      clearInterval(timer);
-    }
+    request: async (options) => await new Promise((resolve, reject) => {
+      const request4 = https.request(
+        {
+          host: "127.0.0.1",
+          port,
+          method: options.method,
+          path: options.path,
+          headers: options.body === void 0 ? options.headers : { ...options.headers, "content-length": String(Buffer.byteLength(options.body, "utf8")) },
+          agent: false,
+          ca: [ca]
+        },
+        (response) => {
+          const chunks = [];
+          response.on("data", (chunk) => {
+            chunks.push(chunk);
+          });
+          response.on("end", () => {
+            resolve({ status: response.statusCode ?? 0, body: Buffer.concat(chunks).toString("utf8") });
+          });
+        }
+      );
+      request4.once("error", reject);
+      if (options.body === void 0) {
+        request4.end();
+      } else {
+        request4.end(options.body);
+      }
+    })
   };
 }
-function observingRoutedRoute(route, tracker) {
-  return {
-    ...route,
-    serve: async (request4, response) => {
-      const observed = tracker.observeExchange({ method: request4.method, url: request4.url, headers: request4.headers });
-      if (observed?.onRequestChunk !== void 0) {
-        request4.body.on("data", (chunk) => {
-          observed.onRequestChunk?.(chunk);
-        });
-        request4.body.on("end", () => {
-          observed.onRequestEnd?.();
-        });
+function controlErrorOf(body) {
+  try {
+    const parsed = JSON.parse(body);
+    if (typeof parsed === "object" && parsed !== null && "error" in parsed && typeof parsed.error === "string") {
+      return parsed.error;
+    }
+  } catch {
+    return body;
+  }
+  return void 0;
+}
+function isRcSessionSummary(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  if (!("id" in value) || !("createdAt" in value) || !("lastSeenAt" in value)) {
+    return false;
+  }
+  return typeof value.id === "string" && typeof value.createdAt === "number" && typeof value.lastSeenAt === "number";
+}
+function isRcWorkerFact(value, valueIs) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  if (!("value" in value) || !("observedAt" in value)) {
+    return false;
+  }
+  return valueIs(value.value) && typeof value.observedAt === "number";
+}
+function isRcSessionStatus(value) {
+  if (!isRcSessionSummary(value)) {
+    return false;
+  }
+  if (!("pending" in value) || !Array.isArray(value.pending)) {
+    return false;
+  }
+  if ("workerState" in value && value.workerState !== void 0 && !isRcWorkerFact(value.workerState, (candidate) => typeof candidate === "string")) {
+    return false;
+  }
+  if ("workerIdleSeconds" in value && value.workerIdleSeconds !== void 0 && !isRcWorkerFact(value.workerIdleSeconds, (candidate) => typeof candidate === "number")) {
+    return false;
+  }
+  return value.pending.every((candidate) => isRcPendingRequestSummary(candidate));
+}
+function isRcPendingRequestSummary(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
+  }
+  if (!("sessionId" in value) || !("requestId" in value) || !("type" in value) || !("summary" in value) || !("observedAt" in value)) {
+    return false;
+  }
+  return typeof value.sessionId === "string" && typeof value.requestId === "string" && typeof value.type === "string" && typeof value.summary === "string" && typeof value.observedAt === "number";
+}
+function sequenceNumsOfBody(body) {
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return void 0;
+  }
+  if (typeof parsed !== "object" || parsed === null || !("sequenceNums" in parsed) || !Array.isArray(parsed.sequenceNums)) {
+    return void 0;
+  }
+  const sequenceNums = [];
+  const values = parsed.sequenceNums;
+  for (const value of values) {
+    if (typeof value !== "number") {
+      return void 0;
+    }
+    sequenceNums.push(value);
+  }
+  return sequenceNums;
+}
+function frontDoorRcControl(transport, token) {
+  const headers = { authorization: `Bearer ${token}` };
+  const listAnswerOf = async (path29, what) => {
+    try {
+      return await transport.request({ method: "GET", path: path29, headers });
+    } catch (error) {
+      throw new Error(`${what}: could not reach the front door's control listener: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+    }
+  };
+  const sessionsOf = (answer, what) => {
+    if (answer.status !== HTTP_STATUS.ok) {
+      throw new Error(`${what} failed (HTTP ${String(answer.status)}): ${controlErrorOf(answer.body) ?? answer.body}`);
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(answer.body);
+    } catch {
+      throw new Error(`${what}: the door's answer was not JSON: ${answer.body}`);
+    }
+    if (typeof parsed !== "object" || parsed === null || !("sessions" in parsed) || !Array.isArray(parsed.sessions)) {
+      throw new Error(`${what}: the door's answer named no sessions list: ${answer.body}`);
+    }
+    const candidates = parsed.sessions;
+    const sessions = [];
+    for (const value of candidates) {
+      if (!isRcSessionSummary(value)) {
+        throw new Error(`${what}: the door's answer named no sessions list: ${answer.body}`);
       }
-      await route.serve(request4, observed === void 0 ? response : teeRoutedResponse(response, observed));
+      sessions.push(value);
     }
+    return sessions;
   };
-}
-function teeRoutedResponse(response, observer) {
-  return {
-    get headersSent() {
-      return response.headersSent;
-    },
-    start: (status, headers) => {
-      observer.onResponse(status, headers);
-      response.start(status, headers);
-    },
-    flush: () => {
-      response.flush();
-    },
-    write: async (chunk) => {
-      observer.onBodyChunk(typeof chunk === "string" ? Buffer.from(chunk, "utf8") : chunk);
-      await response.write(chunk);
-    },
-    end: () => {
-      response.end();
-      observer.onEnd();
-    },
-    destroy: () => {
-      response.destroy();
-      observer.onEnd();
+  const statusesOf = (answer, what) => {
+    if (answer.status !== HTTP_STATUS.ok) {
+      throw new Error(`${what} failed (HTTP ${String(answer.status)}): ${controlErrorOf(answer.body) ?? answer.body}`);
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(answer.body);
+    } catch {
+      throw new Error(`${what}: the door's answer was not JSON: ${answer.body}`);
+    }
+    if (typeof parsed !== "object" || parsed === null || !("statuses" in parsed) || !Array.isArray(parsed.statuses)) {
+      throw new Error(`${what}: the door's answer named no status list: ${answer.body}`);
+    }
+    const statuses = [];
+    for (const value of parsed.statuses) {
+      if (!isRcSessionStatus(value)) {
+        throw new Error(`${what}: the door's answer named no status list: ${answer.body}`);
+      }
+      statuses.push(value);
     }
+    return statuses;
   };
-}
-function rcObserverAsPassthrough(observer) {
-  return {
-    onRequestChunk: (chunk) => {
-      observer.onRequestChunk?.(chunk);
-    },
-    ...observer.onRequestEnd === void 0 ? {} : {
-      onRequestEnd: () => {
-        observer.onRequestEnd?.();
+  const pendingOfAnswer = (answer, what) => {
+    if (answer.status !== HTTP_STATUS.ok) {
+      throw new Error(`${what} failed (HTTP ${String(answer.status)}): ${controlErrorOf(answer.body) ?? answer.body}`);
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(answer.body);
+    } catch {
+      throw new Error(`${what}: the door's answer was not JSON: ${answer.body}`);
+    }
+    if (typeof parsed !== "object" || parsed === null || !("pending" in parsed) || !Array.isArray(parsed.pending)) {
+      throw new Error(`${what}: the door's answer named no pending list: ${answer.body}`);
+    }
+    const pending = [];
+    for (const value of parsed.pending) {
+      if (!isRcPendingRequestSummary(value)) {
+        throw new Error(`${what}: the door's answer named no pending list: ${answer.body}`);
       }
-    },
-    onResponse: (status, headers) => {
-      observer.onResponse(status, headers);
-    },
-    onResponseChunk: (chunk) => {
-      observer.onBodyChunk(chunk);
-    },
-    onEnd: () => {
-      observer.onEnd();
+      pending.push(value);
     }
+    return pending;
   };
-}
-function buildRcUserMessagePayload(uuid, sessionId, text) {
+  const writeOf = async (path29, body, describeFailure) => {
+    let answer;
+    try {
+      answer = await transport.request({ method: "POST", path: path29, headers: { ...headers, "content-type": "application/json" }, body });
+    } catch (error) {
+      return { ok: false, message: `could not reach the front door's control listener: ${error instanceof Error ? error.message : String(error)}` };
+    }
+    if (answer.status === HTTP_STATUS.ok) {
+      const sequenceNums = sequenceNumsOfBody(answer.body);
+      if (sequenceNums === void 0) {
+        return { ok: false, message: `the door accepted the event but its answer named no sequence numbers: ${answer.body}` };
+      }
+      return { ok: true, sequenceNums };
+    }
+    return { ok: false, message: describeFailure(answer.status, controlErrorOf(answer.body) ?? answer.body) };
+  };
+  const sessionQuery = (sessionId) => sessionId === void 0 ? "" : `?session=${encodeURIComponent(sessionId)}`;
   return {
-    type: "user",
-    uuid,
-    session_id: sessionId,
-    parent_tool_use_id: null,
-    message: { role: "user", content: text }
+    listSessions: async () => sessionsOf(await listAnswerOf(`${CONTROL_PATH_PREFIX}/sessions`, "listing the door's Remote Control sessions"), "listing the door's Remote Control sessions"),
+    statusOf: async (sessionId) => statusesOf(await listAnswerOf(`${CONTROL_PATH_PREFIX}/status${sessionQuery(sessionId)}`, "reading the door's Remote Control session status"), "reading the door's Remote Control session status"),
+    pendingOf: async (sessionId) => pendingOfAnswer(await listAnswerOf(`${CONTROL_PATH_PREFIX}/pending${sessionQuery(sessionId)}`, "listing the door's pending Remote Control control requests"), "listing the door's pending Remote Control control requests"),
+    sendPrompt: async (sessionId, text) => await writeOf(`${CONTROL_PATH_PREFIX}/inject`, JSON.stringify({ session: sessionId, text }), (status, message) => `injecting into ${sessionId} failed (HTTP ${String(status)}): ${message}`),
+    answerRequest: async (sessionId, requestId, decision) => await writeOf(
+      `${CONTROL_PATH_PREFIX}/answer`,
+      JSON.stringify({ session: sessionId, request: requestId, approve: decision.approve, ...decision.approve || decision.message === void 0 ? {} : { text: decision.message } }),
+      (status, message) => `answering control request ${requestId} on ${sessionId} failed (HTTP ${String(status)}): ${message}`
+    ),
+    interruptSession: async (sessionId) => await writeOf(`${CONTROL_PATH_PREFIX}/interrupt`, JSON.stringify({ session: sessionId }), (status, message) => `interrupting ${sessionId} failed (HTTP ${String(status)}): ${message}`),
+    setModel: async (sessionId, model) => await writeOf(`${CONTROL_PATH_PREFIX}/set-model`, JSON.stringify({ session: sessionId, model }), (status, message) => `setting the model on ${sessionId} failed (HTTP ${String(status)}): ${message}`),
+    setPermissionMode: async (sessionId, mode) => await writeOf(`${CONTROL_PATH_PREFIX}/set-permission-mode`, JSON.stringify({ session: sessionId, mode }), (status, message) => `setting the permission mode on ${sessionId} failed (HTTP ${String(status)}): ${message}`)
   };
 }
-function buildRcEventWriteBody(payload) {
-  return { events: [{ payload }] };
-}
-function sequenceNumsOf(body) {
-  let parsed;
-  try {
-    parsed = JSON.parse(body);
-  } catch {
-    return void 0;
-  }
-  if (typeof parsed !== "object" || parsed === null || !("results" in parsed) || !Array.isArray(parsed.results)) {
-    return void 0;
-  }
-  const sequenceNums = [];
-  const results = parsed.results;
-  for (const result of results) {
-    if (typeof result !== "object" || result === null || !("sequence_num" in result)) {
-      return void 0;
-    }
-    const sequenceNum = result.sequence_num;
-    if (typeof sequenceNum === "number") {
-      sequenceNums.push(sequenceNum);
-    } else if (typeof sequenceNum === "string" && /^[0-9]+$/.test(sequenceNum)) {
-      sequenceNums.push(Number(sequenceNum));
-    } else {
-      return void 0;
+
+// src/frontdoor/server.ts
+async function* upstreamChunks(stream) {
+  for await (const chunk of stream) {
+    if (typeof chunk === "string") {
+      yield Buffer.from(chunk, "utf8");
+      continue;
     }
-  }
-  return sequenceNums.length === 0 ? void 0 : sequenceNums;
-}
-function rcEventWriteResultFromAnswer(answer) {
-  if (!isSuccessful(answer.status)) {
-    if (answer.status === HTTP_STATUS.unauthorized) {
-      return { ok: false, message: `the API refused the observed Authorization bearer for this session (HTTP 401): the bearer went stale after the door last saw the session's traffic. The session's own client refreshes it on its next call, which the door will observe, so retry once Remote Control has been active again. API answer: ${answer.body}` };
+    if (chunk instanceof Uint8Array) {
+      yield chunk;
     }
-    return { ok: false, message: `the API answered HTTP ${String(answer.status)} to the injected event: ${answer.body}` };
-  }
-  const sequenceNums = sequenceNumsOf(answer.body);
-  if (sequenceNums === void 0) {
-    return { ok: false, message: `the API accepted the injected event but its answer named no results[].sequence_num, so delivery cannot be confirmed: ${answer.body}` };
-  }
-  return { ok: true, sequenceNums };
-}
-function noOAuthCredentialResult(sessionId) {
-  return { ok: false, message: `no claude.ai OAuth bearer has been observed for session ${sessionId}: only worker calls crossed this door, and the worker JWT they carry is answered 401 on the client half. Reconnect Remote Control through this door and the create's own bearer will be observed` };
-}
-function rcWriteHeaders(credential) {
-  const headers = { "content-type": "application/json" };
-  if (credential.authorization !== void 0) {
-    headers.authorization = credential.authorization;
-  }
-  if (credential.anthropicVersion !== void 0) {
-    headers["anthropic-version"] = credential.anthropicVersion;
-  }
-  if (credential.anthropicClientPlatform !== void 0) {
-    headers["anthropic-client-platform"] = credential.anthropicClientPlatform;
-  }
-  return headers;
-}
-async function injectRcUserMessage(deps, sessionId, text) {
-  const credential = deps.credentialOf(sessionId);
-  if (credential === void 0) {
-    return { ok: false, message: `the front door has not observed Remote Control session ${sessionId}: it may never have passed through this door, or it ended or expired (an entry lives only a bounded idle period past its last observed traffic)` };
-  }
-  if (credential.authorization === void 0) {
-    return noOAuthCredentialResult(sessionId);
-  }
-  const body = JSON.stringify(buildRcEventWriteBody(buildRcUserMessagePayload(deps.newUuid(), sessionId, text)));
-  let answer;
-  try {
-    answer = await deps.dial.writeEvents(sessionId, rcWriteHeaders(credential), body);
-  } catch (error) {
-    return { ok: false, message: `the door could not reach the API host to inject into session ${sessionId}: ${error instanceof Error ? error.message : String(error)}` };
   }
-  return rcEventWriteResultFromAnswer(answer);
-}
-function buildRcControlResponsePayload(requestId, decision) {
-  const result = decision.approve ? { behavior: "allow" } : { behavior: "deny", message: decision.message ?? "" };
-  return { type: "control_response", response: { subtype: "success", request_id: requestId, response: result } };
-}
-var RC_PERMISSION_MODES = ["default", "acceptEdits", "bypassPermissions", "plan", "dontAsk", "auto"];
-function isRcPermissionMode(value) {
-  return RC_PERMISSION_MODES.some((mode) => mode === value);
-}
-function buildRcInterruptPayload(requestId) {
-  return { type: "control_request", request_id: requestId, request: { subtype: "interrupt" } };
 }
-function buildRcSetModelPayload(requestId, model) {
-  return { type: "control_request", request_id: requestId, request: { subtype: "set_model", model } };
+
+// src/frontdoor/connectEffects.ts
+var SUCCESS_STATUS_MAX_EXCLUSIVE2 = 300;
+function isSuccessful2(status) {
+  return status >= HTTP_STATUS.ok && status < SUCCESS_STATUS_MAX_EXCLUSIVE2;
 }
-function buildRcSetPermissionModePayload(requestId, mode) {
-  return { type: "control_request", request_id: requestId, request: { subtype: "set_permission_mode", mode } };
+var UPSTREAM_LOCAL_PORT_START = 47900;
+var UPSTREAM_LOCAL_PORT_END = 47919;
+var UPSTREAM_LOCAL_PORT_COUNT = UPSTREAM_LOCAL_PORT_END - UPSTREAM_LOCAL_PORT_START + 1;
+var nextUpstreamLocalPort = UPSTREAM_LOCAL_PORT_START;
+function upstreamLocalPort() {
+  const port = nextUpstreamLocalPort;
+  nextUpstreamLocalPort = nextUpstreamLocalPort === UPSTREAM_LOCAL_PORT_END ? UPSTREAM_LOCAL_PORT_START : nextUpstreamLocalPort + 1;
+  return port;
 }
-async function answerRcControlRequest(deps, sessionId, requestId, decision) {
-  const credential = deps.credentialOf(sessionId);
-  if (credential === void 0) {
-    return { ok: false, message: `the front door has not observed Remote Control session ${sessionId}: it may never have passed through this door, or it ended or expired (an entry lives only a bounded idle period past its last observed traffic)` };
-  }
-  if (credential.authorization === void 0) {
-    return noOAuthCredentialResult(sessionId);
-  }
-  if (!deps.pendingOf(sessionId).some((pending) => pending.requestId === requestId)) {
-    return { ok: false, message: `the front door has not observed control request ${requestId} pending on session ${sessionId}: it was answered already (by this door or by an attached client), it passed its answer deadline (the protocol's permission round-trip bound), or it never passed through this door` };
-  }
-  const body = JSON.stringify(buildRcEventWriteBody(buildRcControlResponsePayload(requestId, decision)));
-  let answer;
-  try {
-    answer = await deps.dial.writeEvents(sessionId, rcWriteHeaders(credential), body);
-  } catch (error) {
-    return { ok: false, message: `the door could not reach the API host to answer on session ${sessionId}: ${error instanceof Error ? error.message : String(error)}` };
-  }
-  const result = rcEventWriteResultFromAnswer(answer);
-  if (result.ok) {
-    deps.completePending(sessionId, requestId);
+var realAddressLookup = (host, _options, callback) => {
+  if (net2.isIP(host) !== 0) {
+    callback(null, [{ address: host, family: net2.isIP(host) }]);
+    return;
   }
-  return result;
+  dns.resolve4(host, (error, addresses) => {
+    if (error !== null) {
+      callback(error, [{ address: "", family: 4 }]);
+      return;
+    }
+    const first = addresses[0];
+    if (first === void 0) {
+      callback(new Error(`no A record for ${host}`), [{ address: "", family: 4 }]);
+      return;
+    }
+    callback(null, [{ address: first, family: 4 }]);
+  });
+};
+var HTTP_PORT = 80;
+var HELD_PORT_ERRNOS = /* @__PURE__ */ new Set(["EADDRINUSE", "EADDRNOTAVAIL"]);
+async function dialOnce(connectOptions) {
+  return await new Promise((resolve) => {
+    const socket = net2.connect(connectOptions);
+    socket.once("connect", () => {
+      resolve({ error: null, socket });
+    });
+    socket.once("error", (error) => {
+      resolve({ error, socket });
+    });
+  });
 }
-async function interruptRcSession(deps, sessionId) {
-  const credential = deps.credentialOf(sessionId);
-  if (credential === void 0) {
-    return { ok: false, message: `the front door has not observed Remote Control session ${sessionId}: it may never have passed through this door, or it ended or expired (an entry lives only a bounded idle period past its last observed traffic)` };
-  }
-  if (credential.authorization === void 0) {
-    return noOAuthCredentialResult(sessionId);
-  }
-  const body = JSON.stringify(buildRcEventWriteBody(buildRcInterruptPayload(deps.newUuid())));
-  let answer;
-  try {
-    answer = await deps.dial.writeEvents(sessionId, rcWriteHeaders(credential), body);
-  } catch (error) {
-    return { ok: false, message: `the door could not reach the API host to interrupt session ${sessionId}: ${error instanceof Error ? error.message : String(error)}` };
-  }
-  return rcEventWriteResultFromAnswer(answer);
+function dialTarget(options, defaultPort) {
+  return { host: typeof options.host === "string" ? options.host : "", port: typeof options.port === "number" ? options.port : defaultPort };
 }
-async function setRcSessionModel(deps, sessionId, model) {
-  if (model === "") {
-    return { ok: false, message: "a set-model write needs a non-empty model id: the SDK's own field treats an omitted or null value as a reset to the session default, which this operation never sends, and an empty string is neither" };
-  }
-  const credential = deps.credentialOf(sessionId);
-  if (credential === void 0) {
-    return { ok: false, message: `the front door has not observed Remote Control session ${sessionId}: it may never have passed through this door, or it ended or expired (an entry lives only a bounded idle period past its last observed traffic)` };
-  }
-  if (credential.authorization === void 0) {
-    return noOAuthCredentialResult(sessionId);
-  }
-  const body = JSON.stringify(buildRcEventWriteBody(buildRcSetModelPayload(deps.newUuid(), model)));
-  let answer;
-  try {
-    answer = await deps.dial.writeEvents(sessionId, rcWriteHeaders(credential), body);
-  } catch (error) {
-    return { ok: false, message: `the door could not reach the API host to set the model on session ${sessionId}: ${error instanceof Error ? error.message : String(error)}` };
-  }
-  return rcEventWriteResultFromAnswer(answer);
+function literalDial(target) {
+  return net2.connect({ host: target.host, port: target.port });
 }
-async function setRcSessionPermissionMode(deps, sessionId, mode) {
-  const credential = deps.credentialOf(sessionId);
-  if (credential === void 0) {
-    return { ok: false, message: `the front door has not observed Remote Control session ${sessionId}: it may never have passed through this door, or it ended or expired (an entry lives only a bounded idle period past its last observed traffic)` };
-  }
-  if (credential.authorization === void 0) {
-    return noOAuthCredentialResult(sessionId);
-  }
-  const body = JSON.stringify(buildRcEventWriteBody(buildRcSetPermissionModePayload(deps.newUuid(), mode)));
-  let answer;
-  try {
-    answer = await deps.dial.writeEvents(sessionId, rcWriteHeaders(credential), body);
-  } catch (error) {
-    return { ok: false, message: `the door could not reach the API host to set the permission mode on session ${sessionId}: ${error instanceof Error ? error.message : String(error)}` };
+async function reservedDial(target) {
+  for (let attempt = 0; ; attempt += 1) {
+    const outcome = await dialOnce({ host: target.host, port: target.port, localPort: upstreamLocalPort(), lookup: realAddressLookup });
+    if (outcome.error === null) {
+      return outcome;
+    }
+    const held = outcome.error.code !== void 0 && HELD_PORT_ERRNOS.has(outcome.error.code);
+    if (!held || attempt === UPSTREAM_LOCAL_PORT_COUNT - 1) {
+      return outcome;
+    }
   }
-  return rcEventWriteResultFromAnswer(answer);
 }
-
-// src/frontdoor/rcControl.ts
-import * as https2 from "node:https";
-var RC_PERMISSION_MODE_LIST = RC_PERMISSION_MODES.join(", ");
-var CONTROL_PATH_PREFIX = "/__agent-shim/rc";
-var CONTROL_BODY_CAP_BYTES = 10485760;
-function answerJson(response, status, body) {
-  const text = JSON.stringify(body);
-  response.writeHead(status, { "content-type": "application/json", "content-length": String(Buffer.byteLength(text, "utf8")) });
-  response.end(text);
+function requestServername(options, fallback) {
+  return "servername" in options && typeof options.servername === "string" && options.servername !== "" ? options.servername : fallback;
 }
-async function readBody(request4) {
-  return await new Promise((resolve, reject) => {
-    const chunks = [];
-    let total = 0;
-    request4.on("data", (chunk) => {
-      total += chunk.length;
-      if (total > CONTROL_BODY_CAP_BYTES) {
-        request4.destroy();
-        reject(new Error("too large"));
+var ExemptHttpAgent = class extends http.Agent {
+  // A reserved-port dial that has to retry cannot produce its socket synchronously, so it settles first and arrives through the callback (node's documented asynchronous createConnection form); a literal dial has nothing to retry and keeps node's own synchronous shape.
+  createConnection(options, oncreate) {
+    const target = dialTarget(options, HTTP_PORT);
+    if (net2.isIP(target.host) !== 0) {
+      return literalDial(target);
+    }
+    void reservedDial(target).then((outcome) => {
+      oncreate?.(outcome.error, outcome.socket);
+    });
+    return void 0;
+  }
+};
+var ExemptTlsAgent = class extends https2.Agent {
+  // The same split as the plain sibling: a literal dial wraps TLS around the socket node's own agent would have returned, a reserved dial settles (retries included) first and arrives through the callback, which is exactly where node's own agent wraps its own dials.
+  createConnection(options, oncreate) {
+    const target = dialTarget(options, HTTPS_PORT);
+    if (net2.isIP(target.host) !== 0) {
+      return tls.connect({ socket: literalDial(target), servername: requestServername(options, target.host), ...tlsFacts(options) });
+    }
+    void reservedDial(target).then((outcome) => {
+      if (outcome.error !== null) {
+        oncreate?.(outcome.error, outcome.socket);
         return;
       }
-      chunks.push(chunk);
-    });
-    request4.on("end", () => {
-      resolve(Buffer.concat(chunks).toString("utf8"));
-    });
-    request4.on("error", () => {
-      reject(new Error("the request body ended early"));
+      oncreate?.(null, tls.connect({ socket: outcome.socket, servername: requestServername(options, target.host), ...tlsFacts(options) }));
     });
-  });
+    return void 0;
+  }
+};
+function tlsFacts(options) {
+  const facts = {};
+  if ("ca" in options && Array.isArray(options.ca)) {
+    facts.ca = options.ca;
+  }
+  if ("rejectUnauthorized" in options && typeof options.rejectUnauthorized === "boolean") {
+    facts.rejectUnauthorized = options.rejectUnauthorized;
+  }
+  return facts;
 }
-function createRcControlHandler(deps) {
-  const sessionsPath = `${CONTROL_PATH_PREFIX}/sessions`;
-  const statusPath = `${CONTROL_PATH_PREFIX}/status`;
-  const pendingPath = `${CONTROL_PATH_PREFIX}/pending`;
-  const injectPath = `${CONTROL_PATH_PREFIX}/inject`;
-  const answerPath = `${CONTROL_PATH_PREFIX}/answer`;
-  const interruptPath = `${CONTROL_PATH_PREFIX}/interrupt`;
-  const setModelPath = `${CONTROL_PATH_PREFIX}/set-model`;
-  const setPermissionModePath = `${CONTROL_PATH_PREFIX}/set-permission-mode`;
-  return (request4, response) => {
-    const presented = request4.headers.authorization;
-    const bearerPrefix = "bearer ".length;
-    const token = typeof presented === "string" && presented.slice(0, bearerPrefix).toLowerCase() === "bearer " ? presented.slice(bearerPrefix) : void 0;
-    if (token === void 0 || !isLiveCapability(token, [deps.expectedToken])) {
-      answerJson(response, HTTP_STATUS.unauthorized, { error: "the front door's control routes demand this generation's control token as a Bearer credential" });
-      return;
-    }
-    const url = new URL(request4.url ?? "/", "http://127.0.0.1");
-    const handle = async () => {
-      if (url.pathname === sessionsPath) {
-        if (request4.method !== "GET") {
-          answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the session list is a GET" });
-          return;
-        }
-        answerJson(response, HTTP_STATUS.ok, { sessions: deps.list() });
-        return;
+function realRcEventDial(target = { host: CONNECT_INTERCEPT_HOST, port: HTTPS_PORT }) {
+  const agent = new ExemptTlsAgent();
+  return {
+    writeEvents: async (sessionId, headers, body) => await new Promise((resolve, reject) => {
+      const options = {
+        host: target.host,
+        port: target.port,
+        method: "POST",
+        path: `/v1/code/sessions/${encodeURIComponent(sessionId)}/events`,
+        // The Host header names the host whose API this is, not the address dialled: a redirected test dials a loopback stand-in while still speaking to the API host by name, exactly as the forwarded paths present their SNI.
+        headers: { ...headers, host: target.servername ?? target.host, "content-length": String(Buffer.byteLength(body, "utf8")) },
+        agent
+      };
+      options.servername = target.servername ?? target.host;
+      if (target.ca !== void 0) {
+        options.ca = [...target.ca];
       }
-      if (url.pathname === statusPath || url.pathname === pendingPath) {
-        if (request4.method !== "GET") {
-          answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the status and pending reads are GETs" });
-          return;
-        }
-        const session = url.searchParams.get("session") ?? void 0;
-        if (session !== void 0 && !deps.statusOf(session).some((entry) => entry.id === session)) {
-          answerJson(response, HTTP_STATUS.notFound, { error: `the front door has not observed Remote Control session ${session}: it may never have passed through this door, or it ended or expired (an entry lives only a bounded idle period past its last observed traffic)` });
-          return;
-        }
-        answerJson(response, HTTP_STATUS.ok, url.pathname === statusPath ? { statuses: deps.statusOf(session) } : { pending: deps.pendingOf(session) });
-        return;
+      if (target.rejectUnauthorized !== void 0) {
+        options.rejectUnauthorized = target.rejectUnauthorized;
       }
-      if (url.pathname === injectPath) {
-        if (request4.method !== "POST") {
-          answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the inject operation is a POST" });
-          return;
-        }
-        let parsed;
-        try {
-          parsed = JSON.parse(await readBody(request4));
-        } catch {
-          answerJson(response, HTTP_STATUS.badRequest, { error: "the inject body is not readable JSON within the control body cap" });
-          return;
-        }
-        if (typeof parsed !== "object" || parsed === null || !("session" in parsed) || !("text" in parsed) || typeof parsed.session !== "string" || typeof parsed.text !== "string" || parsed.session === "" || parsed.text === "") {
-          answerJson(response, HTTP_STATUS.badRequest, { error: "the inject body must be JSON naming a non-empty session id and text" });
-          return;
-        }
-        const result = await deps.inject(parsed.session, parsed.text);
-        if (result.ok) {
-          answerJson(response, HTTP_STATUS.ok, { session: parsed.session, sequenceNums: result.sequenceNums });
-          return;
-        }
-        answerJson(response, HTTP_STATUS.badGateway, { error: result.message });
-        return;
+      const request4 = https2.request(options, (response) => {
+        const chunks = [];
+        response.on("data", (chunk) => {
+          chunks.push(chunk);
+        });
+        response.on("end", () => {
+          resolve({ status: response.statusCode ?? HTTP_BAD_GATEWAY, body: Buffer.concat(chunks).toString("utf8") });
+        });
+      });
+      request4.once("error", reject);
+      request4.end(body);
+    })
+  };
+}
+var NO_CHUNKS = {
+  [Symbol.asyncIterator]: () => ({
+    next: async () => await Promise.resolve({ done: true, value: void 0 })
+  })
+};
+function realRcStreamDial(target = { host: CONNECT_INTERCEPT_HOST, port: HTTPS_PORT }) {
+  const agent = new ExemptTlsAgent();
+  const request4 = async (method, path29, headers, body, signal) => await new Promise((resolve, reject) => {
+    const options = {
+      host: target.host,
+      port: target.port,
+      method,
+      path: path29,
+      // The Host header names the host whose API this is, not the address dialled: a redirected test dials a loopback stand-in while still speaking to the API host by name, exactly as the forwarded paths present their SNI.
+      headers: { ...headers, host: target.servername ?? target.host, ...body === void 0 ? {} : { "content-length": String(Buffer.byteLength(body, "utf8")) } },
+      agent,
+      signal
+    };
+    options.servername = target.servername ?? target.host;
+    if (target.ca !== void 0) {
+      options.ca = [...target.ca];
+    }
+    if (target.rejectUnauthorized !== void 0) {
+      options.rejectUnauthorized = target.rejectUnauthorized;
+    }
+    const sent = https2.request(options, (response) => {
+      resolve({ status: response.statusCode ?? HTTP_BAD_GATEWAY, response });
+    });
+    sent.once("error", reject);
+    if (body === void 0) {
+      sent.end();
+    } else {
+      sent.end(body);
+    }
+  });
+  const readAll = async (response) => {
+    const chunks = [];
+    for await (const chunk of upstreamChunks(response)) {
+      chunks.push(Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString("utf8");
+  };
+  return {
+    announcePresence: async (sessionId, headers, clientId) => {
+      const body = JSON.stringify({ client_id: clientId, clear: false });
+      const { status, response } = await request4("POST", `/v1/code/sessions/${encodeURIComponent(sessionId)}/client/presence`, { ...headers, "content-type": "application/json" }, body, new AbortController().signal);
+      return { status, body: await readAll(response) };
+    },
+    openStream: async (sessionId, headers, resume, signal) => {
+      const path29 = resume === void 0 ? `/v1/code/sessions/${encodeURIComponent(sessionId)}/events/stream` : `/v1/code/sessions/${encodeURIComponent(sessionId)}/events/stream?from_sequence_num=${String(resume.fromSequenceNum)}`;
+      const streamHeaders = resume === void 0 ? headers : { ...headers, "last-event-id": String(resume.fromSequenceNum) };
+      const { status, response } = await request4("GET", path29, streamHeaders, void 0, signal);
+      if (!isSuccessful2(status)) {
+        await readAll(response);
+        return { status, chunks: NO_CHUNKS };
       }
-      if (url.pathname === answerPath) {
-        if (request4.method !== "POST") {
-          answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the answer operation is a POST" });
-          return;
-        }
-        let parsed;
-        try {
-          parsed = JSON.parse(await readBody(request4));
-        } catch {
-          answerJson(response, HTTP_STATUS.badRequest, { error: "the answer body is not readable JSON within the control body cap" });
-          return;
-        }
-        if (typeof parsed !== "object" || parsed === null || !("session" in parsed) || !("request" in parsed) || !("approve" in parsed) || typeof parsed.session !== "string" || typeof parsed.request !== "string" || typeof parsed.approve !== "boolean" || parsed.session === "" || parsed.request === "") {
-          answerJson(response, HTTP_STATUS.badRequest, { error: "the answer body must be JSON naming a non-empty session id, request id, and an approve boolean" });
-          return;
-        }
-        const text = "text" in parsed && typeof parsed.text === "string" ? parsed.text : void 0;
-        if (parsed.approve && text !== void 0 && text !== "") {
-          answerJson(response, HTTP_STATUS.badRequest, { error: "an approval carries no text (the protocol's allow result has no message field); text is the denial message" });
-          return;
-        }
-        const result = await deps.answer(parsed.session, parsed.request, { approve: parsed.approve, message: parsed.approve ? void 0 : text });
-        if (result.ok) {
-          answerJson(response, HTTP_STATUS.ok, { session: parsed.session, request: parsed.request, sequenceNums: result.sequenceNums });
-          return;
-        }
-        answerJson(response, HTTP_STATUS.badGateway, { error: result.message });
+      return { status, chunks: response };
+    }
+  };
+}
+function realConnectEffects() {
+  const plainAgent = new ExemptHttpAgent();
+  const tlsAgent = new ExemptTlsAgent();
+  const listenOnce = async (port, onSocket) => await new Promise((resolve, reject) => {
+    const accepted = /* @__PURE__ */ new Set();
+    const server = net2.createServer((socket) => {
+      accepted.add(socket);
+      socket.on("close", () => {
+        accepted.delete(socket);
+      });
+      onSocket(socket);
+    });
+    server.once("error", reject);
+    server.listen(port, "127.0.0.1", () => {
+      const address = server.address();
+      const bound = typeof address === "object" && address !== null ? address.port : 0;
+      if (bound === 0) {
+        reject(new Error("could not bind a loopback port"));
         return;
       }
-      if (url.pathname === interruptPath) {
-        if (request4.method !== "POST") {
-          answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the interrupt operation is a POST" });
-          return;
+      resolve({
+        port: bound,
+        close: async () => {
+          await new Promise((closeResolve) => {
+            server.close(() => {
+              closeResolve(void 0);
+            });
+            for (const socket of accepted) {
+              socket.destroy();
+            }
+          });
         }
-        let parsed;
+      });
+    });
+  });
+  return {
+    listenLoopback: async (preferredPort, onSocket) => {
+      if (preferredPort !== void 0) {
         try {
-          parsed = JSON.parse(await readBody(request4));
+          return await listenOnce(preferredPort, onSocket);
         } catch {
-          answerJson(response, HTTP_STATUS.badRequest, { error: "the interrupt body is not readable JSON within the control body cap" });
-          return;
-        }
-        if (typeof parsed !== "object" || parsed === null || !("session" in parsed) || typeof parsed.session !== "string" || parsed.session === "") {
-          answerJson(response, HTTP_STATUS.badRequest, { error: "the interrupt body must be JSON naming a non-empty session id" });
-          return;
-        }
-        const result = await deps.interrupt(parsed.session);
-        if (result.ok) {
-          answerJson(response, HTTP_STATUS.ok, { session: parsed.session, sequenceNums: result.sequenceNums });
-          return;
         }
-        answerJson(response, HTTP_STATUS.badGateway, { error: result.message });
-        return;
       }
-      if (url.pathname === setModelPath) {
-        if (request4.method !== "POST") {
-          answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the set-model operation is a POST" });
-          return;
+      return await listenOnce(0, onSocket);
+    },
+    createTlsAcceptor: (leaf, onSecure, alpnProtocols) => {
+      let pendingContext = "";
+      const server = tls.createServer(
+        { key: leaf.keyPem, cert: leaf.certPem, ...alpnProtocols === void 0 ? {} : { ALPNProtocols: [...alpnProtocols] } },
+        (secure) => {
+          onSecure(secure, pendingContext);
         }
-        let parsed;
-        try {
-          parsed = JSON.parse(await readBody(request4));
-        } catch {
-          answerJson(response, HTTP_STATUS.badRequest, { error: "the set-model body is not readable JSON within the control body cap" });
-          return;
+      );
+      server.on("clientError", (_error, socket) => {
+        socket.destroy();
+      });
+      return {
+        // tls.Server is a net.Server whose connection listener wraps the raw socket in the TLS handshake, and emitting the event by hand is what runs that listener on a socket this process already owns (the CONNECT half of the connection) rather than one the server accepted itself.
+        accept: (socket, context) => {
+          pendingContext = context;
+          server.emit("connection", socket);
+        },
+        close: () => {
+          server.close();
         }
-        if (typeof parsed !== "object" || parsed === null || !("session" in parsed) || !("model" in parsed) || typeof parsed.session !== "string" || typeof parsed.model !== "string" || parsed.session === "" || parsed.model === "") {
-          answerJson(response, HTTP_STATUS.badRequest, { error: "the set-model body must be JSON naming a non-empty session id and model id" });
-          return;
+      };
+    },
+    createSniTlsAcceptor: (hosts, leafFor, onSecure) => {
+      const contexts = new Map(
+        hosts.map((host) => {
+          const leaf = leafFor(host);
+          return [host, tls.createSecureContext({ key: leaf.keyPem, cert: leaf.certPem })];
+        })
+      );
+      const server = tls.createServer(
+        {
+          // No default key or cert exists, so the SNI selection is the only source of credentials: an unserved name fails its handshake here, and a client that sent no SNI at all never reaches the selection and fails for want of any certificate, which is exactly the fail-closed shape this surface wants.
+          SNICallback: (servername, callback) => {
+            const context = contexts.get(servername);
+            callback(context === void 0 ? new Error(`the transparent surface serves no host named ${servername}`) : null, context);
+          }
+        },
+        (secure) => {
+          onSecure(secure, typeof secure.servername === "string" ? secure.servername : "");
         }
-        const result = await deps.setModel(parsed.session, parsed.model);
-        if (result.ok) {
-          answerJson(response, HTTP_STATUS.ok, { session: parsed.session, model: parsed.model, sequenceNums: result.sequenceNums });
-          return;
+      );
+      server.on("clientError", (_error, socket) => {
+        socket.destroy();
+      });
+      return {
+        // The same hand-off the single-leaf acceptor uses: emitting the connection event runs the TLS server's own connection listener on a socket this process already owns (the redirect half of the connection) rather than one the server accepted itself.
+        accept: (socket) => {
+          server.emit("connection", socket);
+        },
+        close: () => {
+          server.close();
         }
-        answerJson(response, HTTP_STATUS.badGateway, { error: result.message });
-        return;
+      };
+    },
+    createHttpSession: (handler, onUpgrade) => {
+      const server = http.createServer(handler);
+      server.on("clientError", (_error, socket) => {
+        socket.destroy();
+      });
+      if (onUpgrade !== void 0) {
+        server.on("upgrade", (request4, socket, head) => {
+          onUpgrade(request4, socket, head);
+        });
       }
-      if (url.pathname === setPermissionModePath) {
-        if (request4.method !== "POST") {
-          answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the set-permission-mode operation is a POST" });
-          return;
+      return {
+        serve: (socket) => {
+          server.emit("connection", socket);
+        },
+        close: () => {
+          server.close();
+          server.closeAllConnections();
         }
-        let parsed;
-        try {
-          parsed = JSON.parse(await readBody(request4));
-        } catch {
-          answerJson(response, HTTP_STATUS.badRequest, { error: "the set-permission-mode body is not readable JSON within the control body cap" });
-          return;
+      };
+    },
+    connectTlsUpstream: async (host, port, clientAlpn) => {
+      const dialled = await reservedDial({ host, port });
+      if (dialled.error !== null) {
+        throw dialled.error;
+      }
+      return await new Promise((resolve, reject) => {
+        const secure = tls.connect({ socket: dialled.socket, servername: host, ...clientAlpn === void 0 ? {} : { ALPNProtocols: [clientAlpn] } });
+        secure.once("secureConnect", () => {
+          resolve(secure);
+        });
+        secure.once("error", reject);
+      });
+    },
+    connectTcp: async (host, port) => await new Promise((resolve, reject) => {
+      const socket = net2.connect({ host, port });
+      socket.once("connect", () => {
+        resolve(socket);
+      });
+      socket.once("error", reject);
+    }),
+    forwardHttp: (target, request4, response, observer) => {
+      const headers = forwardableHeaders(request4.headers);
+      const options = {
+        host: target.host,
+        port: target.port,
+        lookup: realAddressLookup,
+        method: request4.method,
+        path: request4.url,
+        headers,
+        agent: target.tls ? tlsAgent : plainAgent
+      };
+      if (target.tls) {
+        options.servername = target.servername ?? target.host;
+        if (target.ca !== void 0) {
+          options.ca = [...target.ca];
         }
-        if (typeof parsed !== "object" || parsed === null || !("session" in parsed) || !("mode" in parsed) || typeof parsed.session !== "string" || parsed.session === "" || !isRcPermissionMode(parsed.mode)) {
-          answerJson(response, HTTP_STATUS.badRequest, { error: `the set-permission-mode body must be JSON naming a non-empty session id and a mode the SDK's own type permits (${RC_PERMISSION_MODE_LIST})` });
-          return;
+        if (target.rejectUnauthorized !== void 0) {
+          options.rejectUnauthorized = target.rejectUnauthorized;
         }
-        const result = await deps.setPermissionMode(parsed.session, parsed.mode);
-        if (result.ok) {
-          answerJson(response, HTTP_STATUS.ok, { session: parsed.session, mode: parsed.mode, sequenceNums: result.sequenceNums });
+      }
+      const onUpstreamResponse = (upstreamResponse) => {
+        observer?.onResponse(upstreamResponse.statusCode ?? HTTP_BAD_GATEWAY, upstreamResponse.headers);
+        response.writeHead(upstreamResponse.statusCode ?? HTTP_BAD_GATEWAY, forwardableHeaders(upstreamResponse.headers));
+        response.flushHeaders();
+        if (observer !== void 0) {
+          upstreamResponse.on("data", (chunk) => {
+            observer.onResponseChunk(chunk);
+          });
+        }
+        upstreamResponse.pipe(response);
+      };
+      const upstream = target.tls ? https2.request(options, onUpstreamResponse) : http.request(options, onUpstreamResponse);
+      upstream.on("error", (error) => {
+        if (response.headersSent) {
+          response.destroy(error);
           return;
         }
-        answerJson(response, HTTP_STATUS.badGateway, { error: result.message });
-        return;
+        const body = `agent-shim headroom: upstream unreachable (${error.message})`;
+        response.writeHead(HTTP_BAD_GATEWAY, { "content-type": "text/plain", "content-length": String(body.length) });
+        response.end(body);
+      });
+      if (observer !== void 0) {
+        request4.on("data", (chunk) => {
+          observer.onRequestChunk(chunk);
+        });
+        if (observer.onRequestEnd !== void 0) {
+          request4.on("end", () => {
+            observer.onRequestEnd?.();
+          });
+        }
+        response.on("close", () => {
+          observer.onEnd();
+        });
       }
-      answerJson(response, HTTP_STATUS.notFound, { error: `no such control route: ${url.pathname}` });
-    };
-    handle().catch((error) => {
-      answerJson(response, HTTP_STATUS.internalServerError, { error: `the control route failed: ${error instanceof Error ? error.message : String(error)}` });
-    });
+      request4.pipe(upstream);
+      request4.socket.setNoDelay(true);
+      upstream.on("socket", (socket) => {
+        socket.setNoDelay(true);
+      });
+    }
   };
 }
-function realRcControlTransport(port, ca) {
+
+// src/frontdoor/rcApi.ts
+import { createORPCClient, ORPCError } from "@orpc/client";
+import { RPCLink } from "@orpc/client/fetch";
+import { eventIterator, os, withEventMeta } from "@orpc/server";
+import { BodyLimitPlugin, RPCHandler } from "@orpc/server/node";
+import { Agent as Agent3, fetch as undiciFetch } from "undici";
+
+// src/frontdoor/rcSchemas.ts
+import { z as z4 } from "zod";
+var RcPermissionModeSchema = z4.enum(RC_PERMISSION_MODES);
+var RcSessionSummarySchema = z4.strictObject({
+  id: z4.string(),
+  createdAt: z4.number(),
+  lastSeenAt: z4.number()
+});
+function workerFactSchema(value) {
+  return z4.strictObject({ value, observedAt: z4.number() });
+}
+var RcPendingRequestSummarySchema = z4.strictObject({
+  sessionId: z4.string(),
+  requestId: z4.string(),
+  type: z4.string(),
+  summary: z4.string(),
+  observedAt: z4.number()
+});
+var RcSessionStatusSchema = z4.strictObject({
+  ...RcSessionSummarySchema.shape,
+  workerState: workerFactSchema(z4.string()).optional(),
+  workerIdleSeconds: workerFactSchema(z4.number()).optional(),
+  pending: z4.readonly(z4.array(RcPendingRequestSummarySchema))
+});
+var RcStreamEnvelopeSchema = z4.looseObject({
+  /** The envelope's own event id, when the host sent one. */
+  event_id: z4.string().optional(),
+  /** The envelope's event type, the discriminator a consumer switches on (`control_request`, `user`, and kin). */
+  event_type: z4.string(),
+  /** The sequence number the host assigned, the value a resume continues after. */
+  sequence_num: z4.int(),
+  /** Who emitted the event (`worker` for the CLI's half, a client id for a client's). */
+  source: z4.string(),
+  /** The event's payload, carried verbatim: its shape is the payload family's, narrowed by whichever consumer needs it. Optional in the schema's own type because the door forwards the host's envelope as it arrived, asserting only the fields it relies on itself. */
+  payload: z4.unknown().optional(),
+  /** When the host created the event; the protocol's own type for this field is not established here, so it is forwarded rather than asserted. */
+  created_at: z4.unknown().optional()
+});
+var RcStreamEventSchema = z4.strictObject({
+  session: z4.string(),
+  envelope: RcStreamEnvelopeSchema
+});
+var RcSessionQuerySchema = z4.strictObject({
+  session: z4.string().min(1).optional()
+});
+var RcSendInputSchema = z4.strictObject({
+  session: z4.string().min(1),
+  text: z4.string().min(1)
+});
+var RcAnswerInputSchema = z4.strictObject({
+  session: z4.string().min(1),
+  request: z4.string().min(1),
+  approve: z4.boolean(),
+  text: z4.string().optional()
+}).refine((input) => !input.approve || input.text === void 0 || input.text === "", { message: "an approval carries no text (the protocol's allow result has no message field); text is the denial message" });
+var RcInterruptInputSchema = z4.strictObject({
+  session: z4.string().min(1)
+});
+var RcSetModelInputSchema = z4.strictObject({
+  session: z4.string().min(1),
+  model: z4.string().min(1)
+});
+var RcSetPermissionModeInputSchema = z4.strictObject({
+  session: z4.string().min(1),
+  mode: RcPermissionModeSchema
+});
+var RcListOutputSchema = z4.strictObject({ sessions: z4.readonly(z4.array(RcSessionSummarySchema)) });
+var RcStatusOutputSchema = z4.strictObject({ statuses: z4.readonly(z4.array(RcSessionStatusSchema)) });
+var RcPendingOutputSchema = z4.strictObject({ pending: z4.readonly(z4.array(RcPendingRequestSummarySchema)) });
+var RcWriteOutputSchema = z4.strictObject({
+  session: z4.string(),
+  sequenceNums: z4.readonly(z4.array(z4.number()))
+});
+var RcAnswerOutputSchema = z4.strictObject({
+  session: z4.string(),
+  request: z4.string(),
+  sequenceNums: z4.readonly(z4.array(z4.number()))
+});
+
+// src/frontdoor/rcApi.ts
+var RC_ORPC_PATH_PREFIX = "/__agent-shim/orpc";
+var RC_SUBSCRIBER_BUFFER_EVENTS = 100;
+function createRcApiRouter(deps) {
+  const authed = os.$context().use(({ context, next }) => {
+    const presented = context.headers.authorization;
+    const bearerPrefix = "bearer ".length;
+    const token = typeof presented === "string" && presented.slice(0, bearerPrefix).toLowerCase() === "bearer " ? presented.slice(bearerPrefix) : void 0;
+    if (token === void 0 || !isLiveCapability(token, [deps.expectedToken])) {
+      throw new ORPCError("UNAUTHORIZED", { message: "the front door's typed API demands this generation's control token as a Bearer credential" });
+    }
+    return next();
+  });
+  const delivered = (sessionId, result) => {
+    if (!result.ok) {
+      throw new ORPCError("BAD_GATEWAY", { message: result.message });
+    }
+    return result.sequenceNums;
+  };
   return {
-    request: async (options) => await new Promise((resolve, reject) => {
-      const request4 = https2.request(
-        {
-          host: "127.0.0.1",
-          port,
-          method: options.method,
-          path: options.path,
-          headers: options.body === void 0 ? options.headers : { ...options.headers, "content-length": String(Buffer.byteLength(options.body, "utf8")) },
-          agent: false,
-          ca: [ca]
-        },
-        (response) => {
-          const chunks = [];
-          response.on("data", (chunk) => {
-            chunks.push(chunk);
-          });
-          response.on("end", () => {
-            resolve({ status: response.statusCode ?? 0, body: Buffer.concat(chunks).toString("utf8") });
-          });
+    rc: {
+      list: authed.output(RcListOutputSchema).handler(() => ({ sessions: deps.list() })),
+      status: authed.input(RcSessionQuerySchema).output(RcStatusOutputSchema).handler(({ input }) => {
+        const statuses = deps.statusOf(input.session);
+        if (input.session !== void 0 && !statuses.some((entry) => entry.id === input.session)) {
+          throw new ORPCError("NOT_FOUND", { message: rcSessionNotObservedMessage(input.session) });
+        }
+        return { statuses };
+      }),
+      pending: authed.input(RcSessionQuerySchema).output(RcPendingOutputSchema).handler(({ input }) => {
+        const pending = deps.pendingOf(input.session);
+        if (input.session !== void 0 && deps.statusOf(input.session).length === 0) {
+          throw new ORPCError("NOT_FOUND", { message: rcSessionNotObservedMessage(input.session) });
+        }
+        return { pending };
+      }),
+      send: authed.input(RcSendInputSchema).output(RcWriteOutputSchema).handler(async ({ input }) => ({ session: input.session, sequenceNums: delivered(input.session, await deps.inject(input.session, input.text)) })),
+      answer: authed.input(RcAnswerInputSchema).output(RcAnswerOutputSchema).handler(async ({ input }) => {
+        const decision = { approve: input.approve, message: input.approve || input.text === void 0 ? void 0 : input.text };
+        return { session: input.session, request: input.request, sequenceNums: delivered(input.session, await deps.answer(input.session, input.request, decision)) };
+      }),
+      interrupt: authed.input(RcInterruptInputSchema).output(RcWriteOutputSchema).handler(async ({ input }) => ({ session: input.session, sequenceNums: delivered(input.session, await deps.interrupt(input.session)) })),
+      setModel: authed.input(RcSetModelInputSchema).output(RcWriteOutputSchema).handler(async ({ input }) => ({ session: input.session, sequenceNums: delivered(input.session, await deps.setModel(input.session, input.model)) })),
+      setPermissionMode: authed.input(RcSetPermissionModeInputSchema).output(RcWriteOutputSchema).handler(async ({ input }) => ({ session: input.session, sequenceNums: delivered(input.session, await deps.setPermissionMode(input.session, input.mode)) })),
+      subscribe: authed.input(RcSessionQuerySchema).output(eventIterator(RcStreamEventSchema)).handler(async function* ({ input, signal }) {
+        const queue = [];
+        let wake;
+        const detach = deps.fanout.subscribe(input.session, (event) => {
+          if (queue.length >= RC_SUBSCRIBER_BUFFER_EVENTS) {
+            queue.shift();
+          }
+          queue.push(event);
+          wake?.();
+        });
+        const ended = new Promise((resolve) => {
+          signal?.addEventListener("abort", () => {
+            resolve();
+          }, { once: true });
+        });
+        try {
+          for (; ; ) {
+            signal?.throwIfAborted();
+            const event = queue.shift();
+            if (event !== void 0) {
+              yield withEventMeta(event, { id: String(event.envelope.sequence_num) });
+              continue;
+            }
+            await Promise.race([
+              new Promise((resolve) => {
+                wake = resolve;
+              }),
+              ended
+            ]);
+          }
+        } finally {
+          detach();
         }
-      );
-      request4.once("error", reject);
-      if (options.body === void 0) {
-        request4.end();
-      } else {
-        request4.end(options.body);
-      }
-    })
+      })
+    }
   };
 }
-function controlErrorOf(body) {
-  try {
-    const parsed = JSON.parse(body);
-    if (typeof parsed === "object" && parsed !== null && "error" in parsed && typeof parsed.error === "string") {
-      return parsed.error;
+function createRcApiNodeHandler(deps) {
+  const handler = new RPCHandler(createRcApiRouter(deps), { plugins: [new BodyLimitPlugin({ maxBodySize: CONTROL_BODY_CAP_BYTES })] });
+  return {
+    pathPrefix: RC_ORPC_PATH_PREFIX,
+    handle: async (request4, response) => await handler.handle(request4, response, { context: { headers: request4.headers }, prefix: RC_ORPC_PATH_PREFIX })
+  };
+}
+function frontDoorRcApiClient(port, ca, token) {
+  const dispatcher = new Agent3({ connect: { ca } });
+  const link = new RPCLink({
+    url: `https://127.0.0.1:${String(port)}${RC_ORPC_PATH_PREFIX}`,
+    headers: { authorization: `Bearer ${token}` },
+    // undici's own Request and Response types and the global ones are distinct declarations of the same standard shapes (the package's bundled types sit beside @types/node's own), and its fetch refuses the global Request instance outright, so the call is rebuilt from the request's parts and the answer re-wrapped through the global constructors, never cast between the two. The request body is one bounded JSON object (the same protocol cap the handler enforces), so reading it whole costs nothing; it is the answer that streams.
+    fetch: async (request4, _init, options) => {
+      const body = request4.body === null ? void 0 : Buffer.from(await request4.arrayBuffer());
+      const answered = await undiciFetch(request4.url, {
+        method: request4.method,
+        headers: [...request4.headers],
+        ...body === void 0 ? {} : { body },
+        dispatcher,
+        ...options.signal === void 0 ? {} : { signal: options.signal }
+      });
+      return new Response(answered.body, { status: answered.status, statusText: answered.statusText, headers: [...answered.headers] });
     }
-  } catch {
-    return body;
-  }
-  return void 0;
+  });
+  return createORPCClient(link);
 }
-function isRcSessionSummary(value) {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  if (!("id" in value) || !("createdAt" in value) || !("lastSeenAt" in value)) {
-    return false;
-  }
-  return typeof value.id === "string" && typeof value.createdAt === "number" && typeof value.lastSeenAt === "number";
+
+// src/frontdoor/rcStream.ts
+var RC_STREAM_EVENT_NAME = "client_event";
+var SSE_BYTE_ORDER_MARK = 65279;
+var RC_STREAM_BACKOFF_MS = 45e3;
+var SUCCESS_STATUS_MAX_EXCLUSIVE3 = 300;
+function isSuccessful3(status) {
+  return status >= HTTP_STATUS.ok && status < SUCCESS_STATUS_MAX_EXCLUSIVE3;
+}
+function createSseParser() {
+  let buffer = "";
+  let eventName;
+  let eventId;
+  let dataLines = [];
+  let seenAnyText = false;
+  return {
+    write: (text) => {
+      let incoming = text;
+      if (!seenAnyText) {
+        seenAnyText = true;
+        incoming = incoming.charCodeAt(0) === SSE_BYTE_ORDER_MARK ? incoming.slice(1) : incoming;
+      }
+      buffer += incoming;
+      const completed = [];
+      for (; ; ) {
+        const carriage = buffer.indexOf("\r");
+        const lineFeed = buffer.indexOf("\n");
+        const end = carriage === -1 ? lineFeed : lineFeed === -1 ? carriage : carriage < lineFeed ? carriage : lineFeed;
+        if (end === -1) {
+          break;
+        }
+        if (buffer[end] === "\r" && end === buffer.length - 1) {
+          break;
+        }
+        const after = buffer[end] === "\r" && buffer[end + 1] === "\n" ? end + 2 : end + 1;
+        const line = buffer.slice(0, end);
+        buffer = buffer.slice(after);
+        if (line === "") {
+          if (dataLines.length > 0) {
+            completed.push({ event: eventName, id: eventId, data: dataLines.join("\n") });
+          }
+          eventName = void 0;
+          dataLines = [];
+          continue;
+        }
+        if (line.startsWith(":")) {
+          continue;
+        }
+        const colon = line.indexOf(":");
+        const field = colon === -1 ? line : line.slice(0, colon);
+        const value = colon === -1 ? "" : line.slice(colon + 1).replace(/^ /, "");
+        if (field === "event") {
+          eventName = value;
+        } else if (field === "data") {
+          dataLines.push(value);
+        } else if (field === "id") {
+          eventId = value;
+        }
+      }
+      return completed;
+    }
+  };
 }
-function isRcWorkerFact(value, valueIs) {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  if (!("value" in value) || !("observedAt" in value)) {
-    return false;
-  }
-  return valueIs(value.value) && typeof value.observedAt === "number";
+function isRecord3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-function isRcSessionStatus(value) {
-  if (!isRcSessionSummary(value)) {
-    return false;
-  }
-  if (!("pending" in value) || !Array.isArray(value.pending)) {
-    return false;
-  }
-  if ("workerState" in value && value.workerState !== void 0 && !isRcWorkerFact(value.workerState, (candidate) => typeof candidate === "string")) {
-    return false;
+function sequenceNumOf(value) {
+  if (typeof value === "number" && Number.isFinite(value) && Number.isInteger(value)) {
+    return value;
   }
-  if ("workerIdleSeconds" in value && value.workerIdleSeconds !== void 0 && !isRcWorkerFact(value.workerIdleSeconds, (candidate) => typeof candidate === "number")) {
-    return false;
+  if (typeof value === "string" && /^[0-9]+$/.test(value)) {
+    return Number(value);
   }
-  return value.pending.every((candidate) => isRcPendingRequestSummary(candidate));
+  return void 0;
 }
-function isRcPendingRequestSummary(value) {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-  if (!("sessionId" in value) || !("requestId" in value) || !("type" in value) || !("summary" in value) || !("observedAt" in value)) {
-    return false;
+function parseRcStreamEnvelope(parsed) {
+  if (parsed.event !== RC_STREAM_EVENT_NAME) {
+    return void 0;
   }
-  return typeof value.sessionId === "string" && typeof value.requestId === "string" && typeof value.type === "string" && typeof value.summary === "string" && typeof value.observedAt === "number";
-}
-function sequenceNumsOfBody(body) {
-  let parsed;
+  let data;
   try {
-    parsed = JSON.parse(body);
+    data = JSON.parse(parsed.data);
   } catch {
     return void 0;
   }
-  if (typeof parsed !== "object" || parsed === null || !("sequenceNums" in parsed) || !Array.isArray(parsed.sequenceNums)) {
+  if (!isRecord3(data)) {
     return void 0;
   }
-  const sequenceNums = [];
-  const values = parsed.sequenceNums;
-  for (const value of values) {
-    if (typeof value !== "number") {
-      return void 0;
-    }
-    sequenceNums.push(value);
+  const eventType = data.event_type;
+  const sequenceNum = sequenceNumOf(data.sequence_num);
+  const source = data.source;
+  if (typeof eventType !== "string" || sequenceNum === void 0 || typeof source !== "string") {
+    return void 0;
   }
-  return sequenceNums;
+  return { ...data, event_type: eventType, sequence_num: sequenceNum, source };
 }
-function frontDoorRcControl(transport, token) {
-  const headers = { authorization: `Bearer ${token}` };
-  const listAnswerOf = async (path29, what) => {
-    try {
-      return await transport.request({ method: "GET", path: path29, headers });
-    } catch (error) {
-      throw new Error(`${what}: could not reach the front door's control listener: ${error instanceof Error ? error.message : String(error)}`, { cause: error });
+function createRcEventFanout() {
+  const perSession = /* @__PURE__ */ new Map();
+  const every = /* @__PURE__ */ new Set();
+  return {
+    publish: (event) => {
+      for (const listener of every) {
+        listener(event);
+      }
+      for (const listener of perSession.get(event.session) ?? []) {
+        listener(event);
+      }
+    },
+    subscribe: (session, listener) => {
+      if (session === void 0) {
+        every.add(listener);
+        return () => {
+          every.delete(listener);
+        };
+      }
+      const listeners = perSession.get(session) ?? /* @__PURE__ */ new Set();
+      perSession.set(session, listeners);
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+        if (listeners.size === 0) {
+          perSession.delete(session);
+        }
+      };
     }
   };
-  const sessionsOf = (answer, what) => {
-    if (answer.status !== HTTP_STATUS.ok) {
-      throw new Error(`${what} failed (HTTP ${String(answer.status)}): ${controlErrorOf(answer.body) ?? answer.body}`);
-    }
-    let parsed;
-    try {
-      parsed = JSON.parse(answer.body);
-    } catch {
-      throw new Error(`${what}: the door's answer was not JSON: ${answer.body}`);
-    }
-    if (typeof parsed !== "object" || parsed === null || !("sessions" in parsed) || !Array.isArray(parsed.sessions)) {
-      throw new Error(`${what}: the door's answer named no sessions list: ${answer.body}`);
-    }
-    const candidates = parsed.sessions;
-    const sessions = [];
-    for (const value of candidates) {
-      if (!isRcSessionSummary(value)) {
-        throw new Error(`${what}: the door's answer named no sessions list: ${answer.body}`);
+}
+function createRcStreamHub(deps) {
+  const attachments = /* @__PURE__ */ new Map();
+  const birth = (sessionId) => {
+    const controller = new AbortController();
+    let stopped = false;
+    return {
+      sessionId,
+      clientId: deps.newClientId(),
+      controller,
+      isStopped: () => stopped,
+      stop: () => {
+        stopped = true;
+        controller.abort();
       }
-      sessions.push(value);
-    }
-    return sessions;
+    };
   };
-  const statusesOf = (answer, what) => {
-    if (answer.status !== HTTP_STATUS.ok) {
-      throw new Error(`${what} failed (HTTP ${String(answer.status)}): ${controlErrorOf(answer.body) ?? answer.body}`);
-    }
-    let parsed;
-    try {
-      parsed = JSON.parse(answer.body);
-    } catch {
-      throw new Error(`${what}: the door's answer was not JSON: ${answer.body}`);
+  const streamHeaders = (credential) => {
+    const headers = { accept: "text/event-stream" };
+    if (credential.authorization !== void 0) {
+      headers.authorization = credential.authorization;
     }
-    if (typeof parsed !== "object" || parsed === null || !("statuses" in parsed) || !Array.isArray(parsed.statuses)) {
-      throw new Error(`${what}: the door's answer named no status list: ${answer.body}`);
+    if (credential.anthropicVersion !== void 0) {
+      headers["anthropic-version"] = credential.anthropicVersion;
     }
-    const statuses = [];
-    for (const value of parsed.statuses) {
-      if (!isRcSessionStatus(value)) {
-        throw new Error(`${what}: the door's answer named no status list: ${answer.body}`);
-      }
-      statuses.push(value);
+    if (credential.anthropicClientPlatform !== void 0) {
+      headers["anthropic-client-platform"] = credential.anthropicClientPlatform;
     }
-    return statuses;
+    return headers;
   };
-  const pendingOfAnswer = (answer, what) => {
-    if (answer.status !== HTTP_STATUS.ok) {
-      throw new Error(`${what} failed (HTTP ${String(answer.status)}): ${controlErrorOf(answer.body) ?? answer.body}`);
-    }
-    let parsed;
-    try {
-      parsed = JSON.parse(answer.body);
-    } catch {
-      throw new Error(`${what}: the door's answer was not JSON: ${answer.body}`);
+  const attempt = async (attachment, credential) => {
+    const headers = streamHeaders(credential);
+    const presence = await deps.dial.announcePresence(attachment.sessionId, headers, attachment.clientId);
+    if (presence.status === HTTP_STATUS.unauthorized) {
+      return "unauthorized";
+    }
+    if (!isSuccessful3(presence.status)) {
+      throw new Error(`the presence call answered HTTP ${String(presence.status)}: ${presence.body}`);
+    }
+    const cursor = deps.sequenceNumOf(attachment.sessionId);
+    const resume = cursor === void 0 ? void 0 : { fromSequenceNum: cursor };
+    const answer = await deps.dial.openStream(attachment.sessionId, headers, resume, attachment.controller.signal);
+    if (answer.status === HTTP_STATUS.unauthorized) {
+      return "unauthorized";
     }
-    if (typeof parsed !== "object" || parsed === null || !("pending" in parsed) || !Array.isArray(parsed.pending)) {
-      throw new Error(`${what}: the door's answer named no pending list: ${answer.body}`);
+    if (!isSuccessful3(answer.status)) {
+      throw new Error(`the client read stream answered HTTP ${String(answer.status)}`);
     }
-    const pending = [];
-    for (const value of parsed.pending) {
-      if (!isRcPendingRequestSummary(value)) {
-        throw new Error(`${what}: the door's answer named no pending list: ${answer.body}`);
+    const parser = createSseParser();
+    for await (const chunk of answer.chunks) {
+      attachment.controller.signal.throwIfAborted();
+      for (const parsed of parser.write(Buffer.from(chunk).toString("utf8"))) {
+        const envelope = parseRcStreamEnvelope(parsed);
+        if (envelope === void 0) {
+          continue;
+        }
+        deps.fileStreamEvent(attachment.sessionId, envelope);
+        deps.fanout.publish({ session: attachment.sessionId, envelope });
       }
-      pending.push(value);
     }
-    return pending;
+    return "dropped";
   };
-  const writeOf = async (path29, body, describeFailure) => {
-    let answer;
-    try {
-      answer = await transport.request({ method: "POST", path: path29, headers: { ...headers, "content-type": "application/json" }, body });
-    } catch (error) {
-      return { ok: false, message: `could not reach the front door's control listener: ${error instanceof Error ? error.message : String(error)}` };
-    }
-    if (answer.status === HTTP_STATUS.ok) {
-      const sequenceNums = sequenceNumsOfBody(answer.body);
-      if (sequenceNums === void 0) {
-        return { ok: false, message: `the door accepted the event but its answer named no sequence numbers: ${answer.body}` };
+  const runLoop = async (attachment) => {
+    let retriedUnauthorized = false;
+    for (; ; ) {
+      if (attachment.isStopped()) {
+        return;
       }
-      return { ok: true, sequenceNums };
+      const live = deps.trackedSessions().includes(attachment.sessionId);
+      const credential = deps.credentialOf(attachment.sessionId);
+      if (!live || credential?.authorization === void 0) {
+        if (attachments.get(attachment.sessionId) === attachment) {
+          attachments.delete(attachment.sessionId);
+        }
+        return;
+      }
+      let outcome;
+      try {
+        outcome = await attempt(attachment, credential);
+      } catch (error) {
+        if (attachment.isStopped()) {
+          return;
+        }
+        deps.log?.(`rc stream ${attachment.sessionId}: attachment failed (${error instanceof Error ? error.message : String(error)}); backing off`);
+        await deps.sleep(deps.backoffMs);
+        retriedUnauthorized = false;
+        continue;
+      }
+      if (attachment.isStopped()) {
+        return;
+      }
+      if (outcome === "dropped") {
+        retriedUnauthorized = false;
+        continue;
+      }
+      if (!retriedUnauthorized) {
+        retriedUnauthorized = true;
+        continue;
+      }
+      deps.log?.(`rc stream ${attachment.sessionId}: the client read stream refused the observed Authorization bearer past one retry; backing off`);
+      await deps.sleep(deps.backoffMs);
+      retriedUnauthorized = false;
     }
-    return { ok: false, message: describeFailure(answer.status, controlErrorOf(answer.body) ?? answer.body) };
   };
-  const sessionQuery = (sessionId) => sessionId === void 0 ? "" : `?session=${encodeURIComponent(sessionId)}`;
   return {
-    listSessions: async () => sessionsOf(await listAnswerOf(`${CONTROL_PATH_PREFIX}/sessions`, "listing the door's Remote Control sessions"), "listing the door's Remote Control sessions"),
-    statusOf: async (sessionId) => statusesOf(await listAnswerOf(`${CONTROL_PATH_PREFIX}/status${sessionQuery(sessionId)}`, "reading the door's Remote Control session status"), "reading the door's Remote Control session status"),
-    pendingOf: async (sessionId) => pendingOfAnswer(await listAnswerOf(`${CONTROL_PATH_PREFIX}/pending${sessionQuery(sessionId)}`, "listing the door's pending Remote Control control requests"), "listing the door's pending Remote Control control requests"),
-    sendPrompt: async (sessionId, text) => await writeOf(`${CONTROL_PATH_PREFIX}/inject`, JSON.stringify({ session: sessionId, text }), (status, message) => `injecting into ${sessionId} failed (HTTP ${String(status)}): ${message}`),
-    answerRequest: async (sessionId, requestId, decision) => await writeOf(
-      `${CONTROL_PATH_PREFIX}/answer`,
-      JSON.stringify({ session: sessionId, request: requestId, approve: decision.approve, ...decision.approve || decision.message === void 0 ? {} : { text: decision.message } }),
-      (status, message) => `answering control request ${requestId} on ${sessionId} failed (HTTP ${String(status)}): ${message}`
-    ),
-    interruptSession: async (sessionId) => await writeOf(`${CONTROL_PATH_PREFIX}/interrupt`, JSON.stringify({ session: sessionId }), (status, message) => `interrupting ${sessionId} failed (HTTP ${String(status)}): ${message}`),
-    setModel: async (sessionId, model) => await writeOf(`${CONTROL_PATH_PREFIX}/set-model`, JSON.stringify({ session: sessionId, model }), (status, message) => `setting the model on ${sessionId} failed (HTTP ${String(status)}): ${message}`),
-    setPermissionMode: async (sessionId, mode) => await writeOf(`${CONTROL_PATH_PREFIX}/set-permission-mode`, JSON.stringify({ session: sessionId, mode }), (status, message) => `setting the permission mode on ${sessionId} failed (HTTP ${String(status)}): ${message}`)
+    reconcile: () => {
+      const live = new Set(deps.trackedSessions());
+      for (const [sessionId, attachment] of attachments) {
+        if (!live.has(sessionId)) {
+          attachment.stop();
+          attachments.delete(sessionId);
+        }
+      }
+      for (const sessionId of live) {
+        if (attachments.has(sessionId)) {
+          continue;
+        }
+        if (deps.credentialOf(sessionId)?.authorization === void 0) {
+          continue;
+        }
+        const attachment = birth(sessionId);
+        attachments.set(sessionId, attachment);
+        void runLoop(attachment).catch((error) => {
+          deps.log?.(`rc stream ${sessionId}: the attachment loop ended unexpectedly (${error instanceof Error ? error.message : String(error)})`);
+        });
+      }
+    },
+    close: () => {
+      for (const attachment of attachments.values()) {
+        attachment.stop();
+      }
+      attachments.clear();
+    }
   };
 }
 
@@ -4395,31 +4985,31 @@ import { randomUUID as randomUUID3 } from "node:crypto";
 // src/headroom/state.ts
 import { createHash as createHash3 } from "node:crypto";
 import path8 from "node:path";
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 var HEADROOM_ANTHROPIC_UPSTREAM = "https://api.anthropic.com";
 var HEADROOM_STATE_SCHEMA_VERSION = 2;
-var HeadroomStateSchema = z4.strictObject({
+var HeadroomStateSchema = z5.strictObject({
   /** The supervisor process owning the daemon. Alive means someone is keeping headroom running. */
-  supervisorPid: z4.number().int().positive().optional(),
+  supervisorPid: z5.number().int().positive().optional(),
   /** The headroom proxy process itself. Absent while the supervisor is between restarts. */
-  headroomPid: z4.number().int().positive().optional(),
+  headroomPid: z5.number().int().positive().optional(),
   /**
    * The unix socket the proxy serves on, inside the owner-only socket directory. Absent until the proxy has passed its readiness check, so "socketPath is set" is itself the ready signal a launcher polls for. The front door reads it on every hop, so a restart (which keeps the generation's path) is followed without anything being relaunched.
    */
-  socketPath: z4.string().min(1).optional(),
+  socketPath: z5.string().min(1).optional(),
   /** The `headroom --version` output of the running install. */
-  version: z4.string().optional(),
+  version: z5.string().optional(),
   /** Hash of the allowlist the running proxy was started with, so a provider-file change is detected as drift. */
-  allowlistHash: z4.string().optional(),
+  allowlistHash: z5.string().optional(),
   /** Hash of the token-saving settings the running proxy was started with, so a settings change is detected as drift. */
-  settingsHash: z4.string().optional(),
+  settingsHash: z5.string().optional(),
   /** The install spec the running install was last installed from, so a `source` config change is detected as drift. */
-  installedSource: z4.string().optional(),
+  installedSource: z5.string().optional(),
   /** The last fatal error, kept across shutdowns so `headroom status` can explain a daemon that is not running. */
-  lastError: z4.string().optional()
+  lastError: z5.string().optional()
 });
-var HeadroomSessionSchema = z4.strictObject({ pid: z4.number().int().positive(), startedAt: z4.number(), supervisorPid: z4.number().int().positive() });
-var HeadroomLockSchema = z4.strictObject({ pid: z4.number().int().positive(), at: z4.number() });
+var HeadroomSessionSchema = z5.strictObject({ pid: z5.number().int().positive(), startedAt: z5.number(), supervisorPid: z5.number().int().positive() });
+var HeadroomLockSchema = z5.strictObject({ pid: z5.number().int().positive(), at: z5.number() });
 function parseJson(raw, schema) {
   if (raw === void 0 || raw.trim() === "") {
     return void 0;
@@ -4599,118 +5189,118 @@ import path10 from "node:path";
 import path9 from "node:path";
 
 // src/usage/schema.ts
-import { z as z5 } from "zod";
+import { z as z6 } from "zod";
 var USAGE_SCHEMA_VERSION = 1;
-var VersionSchema = z5.literal(USAGE_SCHEMA_VERSION);
-var InstantSchema = z5.iso.datetime();
-var TokenCountSchema = z5.number().int().nonnegative();
-var TokenUsageSchema = z5.strictObject({
+var VersionSchema = z6.literal(USAGE_SCHEMA_VERSION);
+var InstantSchema = z6.iso.datetime();
+var TokenCountSchema = z6.number().int().nonnegative();
+var TokenUsageSchema = z6.strictObject({
   inputTokens: TokenCountSchema.optional(),
   outputTokens: TokenCountSchema.optional(),
   cacheCreationInputTokens: TokenCountSchema.optional(),
   cacheReadInputTokens: TokenCountSchema.optional()
 });
 var LIMIT_KINDS = ["rate-limited", "quota-exhausted"];
-var LimitClassificationSchema = z5.strictObject({
-  kind: z5.enum(LIMIT_KINDS),
+var LimitClassificationSchema = z6.strictObject({
+  kind: z6.enum(LIMIT_KINDS),
   /** Seconds to wait before retrying, from the response's `retry-after`. */
-  retryAfterSeconds: z5.number().nonnegative().optional(),
+  retryAfterSeconds: z6.number().nonnegative().optional(),
   /** When the limiting window resets, from the upstream's own reset header. */
   resetAt: InstantSchema.optional(),
   /** The window the upstream named as the binding one (`anthropic-ratelimit-unified-representative-claim`), such as `five_hour` or `seven_day`. */
-  window: z5.string().optional(),
+  window: z6.string().optional(),
   /** The signals the classification rests on, each `<name>=<value>` from a response header or the error body's `type` or `code`. Never the error message. */
-  evidence: z5.array(z5.string())
+  evidence: z6.array(z6.string())
 });
-var UsageRecordSchema = z5.strictObject({
+var UsageRecordSchema = z6.strictObject({
   schemaVersion: VersionSchema,
   /** When the front door received the request. */
   at: InstantSchema,
   /** The launching identity, when the launch resolved one. */
-  identity: z5.string().optional(),
+  identity: z6.string().optional(),
   /** `anthropic` for an OAuth session's request to Claude Code's own API, otherwise the provider's name. */
-  provider: z5.string(),
+  provider: z6.string(),
   /** The launch's session id, generated per launch. */
-  sessionId: z5.string().optional(),
+  sessionId: z6.string().optional(),
   /** The project the launch ran in (its git repository root), when the launch sent one: headroom launches do. */
-  project: z5.string().optional(),
+  project: z6.string().optional(),
   /** The front-door route that served the request. */
-  route: z5.string(),
-  method: z5.string(),
+  route: z6.string(),
+  method: z6.string(),
   /** The API path as the upstream sees it (`/v1/messages`), without the provider prefix or a query string. */
-  endpoint: z5.string(),
+  endpoint: z6.string(),
   /** The model the response named. */
-  model: z5.string().optional(),
-  status: z5.number().int(),
+  model: z6.string().optional(),
+  status: z6.number().int(),
   /** Milliseconds from the request's arrival to its response head. */
-  latencyMs: z5.number().int().nonnegative(),
+  latencyMs: z6.number().int().nonnegative(),
   /** Milliseconds from the request's arrival to the end of its response body. */
-  durationMs: z5.number().int().nonnegative(),
+  durationMs: z6.number().int().nonnegative(),
   /** Whether the client received the whole body. */
-  outcome: z5.enum(["completed", "aborted"]),
+  outcome: z6.enum(["completed", "aborted"]),
   usage: TokenUsageSchema.optional(),
   /** The response's quota and rate-limit headers, by name (see `isRateLimitHeader`). */
-  rateLimitHeaders: z5.record(z5.string(), z5.string()).optional(),
+  rateLimitHeaders: z6.record(z6.string(), z6.string()).optional(),
   limit: LimitClassificationSchema.optional(),
   /** The upstream's request id (`request-id`), for matching a record to the provider's own logs. */
-  requestId: z5.string().optional()
+  requestId: z6.string().optional()
 });
-var QuotaWindowSchema = z5.strictObject({
+var QuotaWindowSchema = z6.strictObject({
   /** The fraction of the window used, as the upstream reports it (0 to 1). */
-  utilization: z5.number().nonnegative().optional(),
+  utilization: z6.number().nonnegative().optional(),
   resetsAt: InstantSchema.optional(),
   /** The window's own status (`allowed`, `allowed_warning`, `rejected`). */
-  status: z5.string().optional()
+  status: z6.string().optional()
 });
-var UnifiedRateLimitSchema = z5.strictObject({
+var UnifiedRateLimitSchema = z6.strictObject({
   /** The overall status: `allowed`, `allowed_warning` or `rejected`. */
-  status: z5.string().optional(),
+  status: z6.string().optional(),
   fiveHour: QuotaWindowSchema.optional(),
   sevenDay: QuotaWindowSchema.optional(),
   /** The window that currently binds. */
-  representativeClaim: z5.string().optional(),
+  representativeClaim: z6.string().optional(),
   /** When the binding window resets. */
   resetAt: InstantSchema.optional(),
   /** Whether usage beyond the plan (extra usage) is available: `allowed` or `rejected`. */
-  overageStatus: z5.string().optional()
+  overageStatus: z6.string().optional()
 });
-var RateLimitStateSchema = z5.strictObject({
+var RateLimitStateSchema = z6.strictObject({
   observedAt: InstantSchema,
   /** Every quota and rate-limit header on that response, by name. */
-  headers: z5.record(z5.string(), z5.string()),
+  headers: z6.record(z6.string(), z6.string()),
   unified: UnifiedRateLimitSchema.optional()
 });
 var LimitEventSchema = LimitClassificationSchema.extend({
   observedAt: InstantSchema,
-  status: z5.number().int()
+  status: z6.number().int()
 });
-var ProviderQuotaWindowSchema = z5.strictObject({
+var ProviderQuotaWindowSchema = z6.strictObject({
   /** What the window measures, in the provider's terms (`tokens`, `tool-calls`). */
-  measures: z5.string(),
+  measures: z6.string(),
   /** The window's length in milliseconds, when the provider's unit is one this project knows; absent for an unrecognised unit, with `period` carrying the raw code. */
-  periodMs: z5.number().int().positive().optional(),
+  periodMs: z6.number().int().positive().optional(),
   /** The provider's own description of the period when `periodMs` could not be derived, such as `unit 4 x 1`. */
-  period: z5.string().optional(),
+  period: z6.string().optional(),
   /** The fraction of the window used (0 to 1). */
-  utilization: z5.number().nonnegative(),
+  utilization: z6.number().nonnegative(),
   resetsAt: InstantSchema.optional(),
   /** Absolute counts, when the provider reports them for this window. */
-  limit: z5.number().nonnegative().optional(),
-  used: z5.number().nonnegative().optional(),
-  remaining: z5.number().nonnegative().optional()
+  limit: z6.number().nonnegative().optional(),
+  used: z6.number().nonnegative().optional(),
+  remaining: z6.number().nonnegative().optional()
 });
-var ProviderQuotaSchema = z5.strictObject({
+var ProviderQuotaSchema = z6.strictObject({
   observedAt: InstantSchema,
   /** Which usage endpoint produced it (`z.ai`). */
-  source: z5.string(),
+  source: z6.string(),
   /** The subscription level the endpoint reports, when it does. */
-  level: z5.string().optional(),
-  windows: z5.array(ProviderQuotaWindowSchema)
+  level: z6.string().optional(),
+  windows: z6.array(ProviderQuotaWindowSchema)
 });
-var ProviderUsageStateSchema = z5.strictObject({
+var ProviderUsageStateSchema = z6.strictObject({
   lastRequestAt: InstantSchema,
-  lastStatus: z5.number().int(),
-  lastModel: z5.string().optional(),
+  lastStatus: z6.number().int(),
+  lastModel: z6.string().optional(),
   /** The latest rate-limit state, from the last response that carried any rate-limit header. */
   rateLimit: RateLimitStateSchema.optional(),
   /** The latest classified refusal. It stays after later successes, so a reader compares its `resetAt` (or `observedAt` plus `retryAfterSeconds`) with the current time. */
@@ -4718,31 +5308,31 @@ var ProviderUsageStateSchema = z5.strictObject({
   /** The latest quota the provider's usage endpoint reported, for providers whose quota is not visible in response headers. */
   quota: ProviderQuotaSchema.optional()
 });
-var AccountMetadataSchema = z5.strictObject({
-  accountUuid: z5.string().optional(),
-  emailAddress: z5.string().optional(),
-  displayName: z5.string().optional(),
-  organizationUuid: z5.string().optional(),
-  organizationName: z5.string().optional(),
-  organizationType: z5.string().optional(),
-  organizationRole: z5.string().optional(),
-  workspaceRole: z5.string().optional(),
-  billingType: z5.string().optional(),
-  seatTier: z5.string().optional(),
-  organizationRateLimitTier: z5.string().optional(),
-  userRateLimitTier: z5.string().optional(),
-  hasExtraUsageEnabled: z5.boolean().optional(),
-  subscriptionCreatedAt: z5.string().optional(),
-  accountCreatedAt: z5.string().optional()
+var AccountMetadataSchema = z6.strictObject({
+  accountUuid: z6.string().optional(),
+  emailAddress: z6.string().optional(),
+  displayName: z6.string().optional(),
+  organizationUuid: z6.string().optional(),
+  organizationName: z6.string().optional(),
+  organizationType: z6.string().optional(),
+  organizationRole: z6.string().optional(),
+  workspaceRole: z6.string().optional(),
+  billingType: z6.string().optional(),
+  seatTier: z6.string().optional(),
+  organizationRateLimitTier: z6.string().optional(),
+  userRateLimitTier: z6.string().optional(),
+  hasExtraUsageEnabled: z6.boolean().optional(),
+  subscriptionCreatedAt: z6.string().optional(),
+  accountCreatedAt: z6.string().optional()
 });
-var UsageSnapshotSchema = z5.strictObject({
+var UsageSnapshotSchema = z6.strictObject({
   schemaVersion: VersionSchema,
-  identity: z5.string(),
+  identity: z6.string(),
   updatedAt: InstantSchema,
   /** The identity's account metadata as of `updatedAt`. */
   account: AccountMetadataSchema.optional(),
   /** Latest state per provider, keyed by provider name (`anthropic` for OAuth sessions). */
-  providers: z5.record(z5.string(), ProviderUsageStateSchema)
+  providers: z6.record(z6.string(), ProviderUsageStateSchema)
 });
 
 // src/usage/account.ts
@@ -4946,20 +5536,20 @@ function quotaWarnings(snapshot, provider, nowMs) {
 }
 
 // src/usage/plan.ts
-import { z as z6 } from "zod";
-var PlanClassSchema = z6.union([
-  z6.strictObject({
-    kind: z6.literal("subscription"),
+import { z as z7 } from "zod";
+var PlanClassSchema = z7.union([
+  z7.strictObject({
+    kind: z7.literal("subscription"),
     /** The plan's size as a multiple of the smallest subscription tier (Max 5x is 5, Max 20x is 20). */
-    capacity: z6.number().positive(),
+    capacity: z7.number().positive(),
     /** False when the tier string named no multiplier and no tier this project knows, so `capacity` is the neutral 1 rather than a reading. */
-    recognised: z6.boolean(),
+    recognised: z7.boolean(),
     /** The tier string the classification rests on, when the account had one. */
-    tier: z6.string().optional()
+    tier: z7.string().optional()
   }),
-  z6.strictObject({
-    kind: z6.literal("pay-per-use"),
-    tier: z6.string().optional()
+  z7.strictObject({
+    kind: z7.literal("pay-per-use"),
+    tier: z7.string().optional()
   })
 ]);
 var TIER_MULTIPLIER = /(?:^|_)(\d+)x$/;
@@ -5028,17 +5618,17 @@ function parseUnifiedRateLimit(headers) {
 }
 
 // src/usage/scan.ts
-import { z as z7 } from "zod";
-var AnthropicUsageSchema = z7.looseObject({
-  input_tokens: z7.number().int().nonnegative().nullish(),
-  output_tokens: z7.number().int().nonnegative().nullish(),
-  cache_creation_input_tokens: z7.number().int().nonnegative().nullish(),
-  cache_read_input_tokens: z7.number().int().nonnegative().nullish()
+import { z as z8 } from "zod";
+var AnthropicUsageSchema = z8.looseObject({
+  input_tokens: z8.number().int().nonnegative().nullish(),
+  output_tokens: z8.number().int().nonnegative().nullish(),
+  cache_creation_input_tokens: z8.number().int().nonnegative().nullish(),
+  cache_read_input_tokens: z8.number().int().nonnegative().nullish()
 });
-var ErrorObjectSchema = z7.looseObject({
-  type: z7.string().optional(),
-  code: z7.union([z7.string(), z7.number()]).optional(),
-  message: z7.string().optional()
+var ErrorObjectSchema = z8.looseObject({
+  type: z8.string().optional(),
+  code: z8.union([z8.string(), z8.number()]).optional(),
+  message: z8.string().optional()
 });
 
 // src/usage/middleware.ts
@@ -5198,7 +5788,7 @@ function rankPool(input) {
 
 // src/usage/poolPick.ts
 import path11 from "node:path";
-import { z as z8 } from "zod";
+import { z as z9 } from "zod";
 
 // src/usage/store.ts
 var DAY_MS2 = 864e5;
@@ -5207,10 +5797,10 @@ var USAGE_RETENTION_MS = DAYS_IN_WEEK * DAY_MS2;
 
 // src/usage/poolPick.ts
 var SCHEMA_VERSION = 1;
-var PickEntrySchema = z8.strictObject({ identity: z8.string().min(1), at: z8.iso.datetime() });
-var PicksFileSchema = z8.strictObject({
-  schemaVersion: z8.literal(SCHEMA_VERSION),
-  picks: z8.record(z8.string().min(1), PickEntrySchema)
+var PickEntrySchema = z9.strictObject({ identity: z9.string().min(1), at: z9.iso.datetime() });
+var PicksFileSchema = z9.strictObject({
+  schemaVersion: z9.literal(SCHEMA_VERSION),
+  picks: z9.record(z9.string().min(1), PickEntrySchema)
 });
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
@@ -5410,33 +6000,33 @@ function collectPoolPick(params) {
 }
 
 // src/usage/pickReportSchema.ts
-import { z as z9 } from "zod";
-var PoolPickCandidateViewSchema = z9.strictObject({
-  identity: z9.string(),
+import { z as z10 } from "zod";
+var PoolPickCandidateViewSchema = z10.strictObject({
+  identity: z10.string(),
   /** In pick order: `scored` has usable quota data, `unknown` has none, `pay-per-use` bills by use, `ineligible` is refused right now. */
-  class: z9.enum(["scored", "unknown", "pay-per-use", "ineligible"]),
+  class: z10.enum(["scored", "unknown", "pay-per-use", "ineligible"]),
   /** Plan-size-weighted remaining quota per hour until its reset; present for `scored` only. */
-  score: z9.number().optional(),
+  score: z10.number().optional(),
   /** False when the five-hour window would run dry, at the observed pace, before it resets. */
-  feasible: z9.boolean(),
+  feasible: z10.boolean(),
   /** When an `ineligible` member can be used again, as an ISO instant. */
-  blockedUntil: z9.iso.datetime().optional(),
+  blockedUntil: z10.iso.datetime().optional(),
   plan: PlanClassSchema,
   /** The facts behind the class and score, in the order they matter. */
-  reasons: z9.array(z9.string())
+  reasons: z10.array(z10.string())
 });
-var PoolPickReportSchema = z9.strictObject({
-  pool: z9.string(),
-  directory: z9.string(),
+var PoolPickReportSchema = z10.strictObject({
+  pool: z10.string(),
+  directory: z10.string(),
   /** The member a launch would run as, absent when every member is refused. */
-  pick: z9.string().optional(),
-  candidates: z9.array(PoolPickCandidateViewSchema),
+  pick: z10.string().optional(),
+  candidates: z10.array(PoolPickCandidateViewSchema),
   /** Members that name an identity that does not exist; a launch skips them. */
-  missing: z9.array(z9.string()),
+  missing: z10.array(z10.string()),
   /** When nothing can be picked, the soonest any member returns. */
-  earliestReturn: z9.strictObject({ identity: z9.string(), at: z9.iso.datetime() }).optional(),
+  earliestReturn: z10.strictObject({ identity: z10.string(), at: z10.iso.datetime() }).optional(),
   /** Why the last-pick record could not be read, when that is the case. */
-  stickyProblem: z9.string().optional()
+  stickyProblem: z10.string().optional()
 });
 
 // src/headroom/ensure.ts
@@ -5599,10 +6189,10 @@ function pruneStaleHeadroomSockets(fs12, paths, isRunning) {
 }
 
 // src/headroom/source.ts
-import { z as z10 } from "zod";
+import { z as z11 } from "zod";
 var GIT_SPEC_RE = /git\+[^@\s]+(?:@([^\s#]+))?/;
 var COMMIT_SHA_RE = /^[0-9a-f]{40}$/i;
-var DirectUrlSchema = z10.object({ vcs_info: z10.object({ commit_id: z10.string() }) });
+var DirectUrlSchema = z11.object({ vcs_info: z11.object({ commit_id: z11.string() }) });
 function isMovingGitSource(spec) {
   const match = GIT_SPEC_RE.exec(spec);
   if (match === null) {
@@ -5915,9 +6505,9 @@ function evaluateAmbientCredentialGuard(params) {
 
 // src/paths.ts
 import fs3 from "node:fs";
-import os from "node:os";
+import os2 from "node:os";
 import path14 from "node:path";
-function resolveAgentShimHome(env = process.env, home = os.homedir(), isDirectory = isExistingDirectory) {
+function resolveAgentShimHome(env = process.env, home = os2.homedir(), isDirectory = isExistingDirectory) {
   const fromEnv = env.AGENT_SHIM_HOME;
   if (fromEnv !== void 0 && fromEnv !== "") {
     return fromEnv;
@@ -5934,7 +6524,7 @@ function resolveClaudeHome() {
   if (fromEnv !== void 0 && fromEnv !== "") {
     return fromEnv;
   }
-  return path14.join(os.homedir(), ".claude");
+  return path14.join(os2.homedir(), ".claude");
 }
 function buildLayoutPaths(root) {
   return {
@@ -6316,11 +6906,11 @@ import fs6 from "node:fs";
 import path17 from "node:path";
 
 // src/credentialCache.ts
-import { z as z11 } from "zod";
+import { z as z12 } from "zod";
 var MS_PER_UNIT = { s: 1e3, m: 6e4, h: 36e5, d: 864e5 };
-var CachedCredentialSchema = z11.strictObject({
-  token: z11.string().min(1),
-  fetchedAt: z11.number().int().nonnegative(),
+var CachedCredentialSchema = z12.strictObject({
+  token: z12.string().min(1),
+  fetchedAt: z12.number().int().nonnegative(),
   source: CredentialSourceSchema
 });
 function effectiveStore(cache, platform) {
@@ -6586,14 +7176,14 @@ function providerExists(paths, name) {
 var LEGACY_PROVIDER_FIELDS = ["tokenEnv", "tokenCommand", "authScheme"];
 var LEGACY_ENV_CREDENTIAL_KEYS = Object.values(CREDENTIAL_TARGET_VARS);
 var LEGACY_LITERAL_PLACEHOLDER = "<the value of env.ANTHROPIC_AUTH_TOKEN>";
-function isRecord3(value) {
+function isRecord4(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function legacyProviderConversion(raw) {
-  if (!isRecord3(raw) || "credential" in raw) {
+  if (!isRecord4(raw) || "credential" in raw) {
     return void 0;
   }
-  const env = isRecord3(raw.env) ? raw.env : void 0;
+  const env = isRecord4(raw.env) ? raw.env : void 0;
   const legacyEnvKeys = env === void 0 ? [] : Object.keys(env).filter((key) => LEGACY_ENV_CREDENTIAL_KEYS.includes(key));
   const fields = [...LEGACY_PROVIDER_FIELDS.filter((field) => field in raw), ...legacyEnvKeys.map((key) => `env.${key}`)];
   if (fields.length === 0) {
@@ -6906,7 +7496,7 @@ function removeDirectoryRule(paths, rulePath) {
 }
 
 // src/checkReport.ts
-import os4 from "node:os";
+import os5 from "node:os";
 
 // src/launcher/cascade.ts
 import path19 from "node:path";
@@ -7079,15 +7669,15 @@ function realCredentialCacheEnv(paths) {
 import { spawn, spawnSync as spawnSync2 } from "node:child_process";
 import { createHash as createHash5 } from "node:crypto";
 import fs8 from "node:fs";
-import os3 from "node:os";
+import os4 from "node:os";
 import path22 from "node:path";
 import { isSea } from "node:sea";
 
 // src/versionDiscovery.ts
-import os2 from "node:os";
+import os3 from "node:os";
 import path21 from "node:path";
 function defaultVersionsDir() {
-  return path21.join(os2.homedir(), ".local", "share", "claude", "versions");
+  return path21.join(os3.homedir(), ".local", "share", "claude", "versions");
 }
 var NUMERIC_DOTTED_VERSION_RE = /^\d+(?:\.\d+)*$/;
 function isNumericDottedVersion(name) {
@@ -7303,7 +7893,7 @@ var realRunPort = {
   }
 };
 function expandHome2(filePath) {
-  return filePath.startsWith("~/") ? path22.join(os3.homedir(), filePath.slice(1)) : filePath;
+  return filePath.startsWith("~/") ? path22.join(os4.homedir(), filePath.slice(1)) : filePath;
 }
 var MACOS_GUI_SESSION_MANAGER = "Aqua";
 function hasDesktopSession() {
@@ -7557,7 +8147,7 @@ function realResolveClaudeBinary(isOwnBinary) {
 
 // src/checkReport.ts
 import path23 from "node:path";
-import { z as z12 } from "zod";
+import { z as z13 } from "zod";
 
 // src/cli/bool.ts
 function parseBoolWord(input) {
@@ -7672,9 +8262,9 @@ function lookupKeychainService(run, farmRoot) {
     note: serviceName === void 0 ? `A Keychain entry was found for account "${farmRoot}" but its service name could not be parsed from security's output.` : `Keychain service name for this identity: "${serviceName}".`
   };
 }
-var SettingsSecretsShapeSchema = z12.looseObject({
-  env: z12.record(z12.string(), z12.unknown()).optional(),
-  hooks: z12.record(z12.string(), z12.array(z12.unknown())).optional()
+var SettingsSecretsShapeSchema = z13.looseObject({
+  env: z13.record(z13.string(), z13.unknown()).optional(),
+  hooks: z13.record(z13.string(), z13.array(z13.unknown())).optional()
 });
 function hookCommandCountOf(group) {
   if (typeof group !== "object" || group === null) {
@@ -7888,7 +8478,7 @@ function loadCheckProvider(paths, name) {
 }
 function collectCheckReport(params) {
   const { paths, cwd } = params;
-  const home = os4.homedir();
+  const home = os5.homedir();
   const claudeHome = resolveClaudeHome();
   const read = cosmiconfigReader();
   const classification = loadClassification(paths);
@@ -7968,11 +8558,11 @@ function collectCheckReport(params) {
 // src/claudeShim.ts
 import fs9 from "node:fs";
 import path24 from "node:path";
-import { z as z13 } from "zod";
-var ClaudeShimStateSchema = z13.strictObject({
-  targetPath: z13.string().min(1),
-  method: z13.enum(["hardlink", "copy"]),
-  installedAtMs: z13.number()
+import { z as z14 } from "zod";
+var ClaudeShimStateSchema = z14.strictObject({
+  targetPath: z14.string().min(1),
+  method: z14.enum(["hardlink", "copy"]),
+  installedAtMs: z14.number()
 });
 function commandFilename(ownExecutablePath, commandName) {
   return ownExecutablePath.toLowerCase().endsWith(".exe") ? `${commandName}.exe` : commandName;
@@ -8531,9 +9121,11 @@ var BOOLEAN_FLAGS = [
 ];
 var LAUNCHER_FLAG_NAMES = [
   ...VALUED_FLAGS,
+  "--native",
   "--no-provider",
   ...BOOLEAN_FLAGS.flatMap(({ flag }) => [flag, `--no-${flag.slice(2)}`])
 ];
+var NATIVE_FLAG = "--native";
 var TERMINATOR2 = "--";
 function matchValuedFlag(token) {
   for (const flag of VALUED_FLAGS) {
@@ -8561,6 +9153,7 @@ function parseLauncherArgv(argv) {
   const first = argv[0];
   const positionalIdentity = first !== void 0 && first.startsWith("@") && first.length > 1 ? first.slice(1) : void 0;
   const remaining = positionalIdentity === void 0 ? argv : argv.slice(1);
+  let native = false;
   let flagIdentity;
   let configProfile;
   let provider;
@@ -8582,6 +9175,10 @@ function parseLauncherArgv(argv) {
       provider = false;
       continue;
     }
+    if (token === NATIVE_FLAG) {
+      native = true;
+      continue;
+    }
     const booleanFlag = matchBooleanFlag(token);
     if (booleanFlag !== void 0) {
       booleans[booleanFlag.key] = booleanFlag.value;
@@ -8635,6 +9232,7 @@ function parseLauncherArgv(argv) {
     ...identity === void 0 ? {} : { identity },
     ...configProfile === void 0 ? {} : { configProfile },
     ...provider === void 0 ? {} : { provider },
+    ...native ? { native: true } : {},
     ...booleans,
     categoryFlags,
     shareFlags,
@@ -9161,7 +9759,7 @@ function prepareLaunch(params) {
 }
 
 // src/launchWiring.ts
-import os5 from "node:os";
+import os6 from "node:os";
 import { randomUUID as randomUUID5 } from "node:crypto";
 
 // src/frontdoor/realFrontDoorPort.ts
@@ -9310,7 +9908,7 @@ function realFrontDoorPort(paths, spawnDaemon) {
 
 // src/launchWiring.ts
 function buildFarmRuntime(paths, cwd) {
-  const home = os5.homedir();
+  const home = os6.homedir();
   const read = cosmiconfigReader();
   const classification = loadClassification(paths);
   const loaded = loadCascadeInput({ paths, home, cwd, read });
@@ -9344,6 +9942,9 @@ function buildFarmRuntime(paths, cwd) {
     ...loaded.globalConfig?.pools === void 0 ? {} : { pools: loaded.globalConfig.pools }
   };
 }
+function realClaudeBinaryResolver(paths) {
+  return realResolveClaudeBinary(resolveOwnBinaryCheck(paths, realContentSourcePath()));
+}
 function realPrepareLaunchParams(paths, options) {
   const { farm } = options;
   return {
@@ -9351,7 +9952,7 @@ function realPrepareLaunchParams(paths, options) {
     fs: realFsPort,
     proc: options.proc,
     log: options.log,
-    resolveClaudeBinary: realResolveClaudeBinary(resolveOwnBinaryCheck(paths, realContentSourcePath())),
+    resolveClaudeBinary: realClaudeBinaryResolver(paths),
     farm: farm.runtime,
     headroom: realHeadroomPort(paths, { spawnDaemon: options.spawnDaemon, cwd: farm.runtime.cwd }),
     frontdoor: realFrontDoorPort(paths, options.spawnDaemon),
@@ -9441,11 +10042,16 @@ export {
   ProviderNotFoundError,
   ProviderSchema,
   RC_IDLE_EXPIRY_MS,
+  RC_ORPC_PATH_PREFIX,
   RC_PENDING_DEADLINE_MS,
   RC_PERMISSION_MODES,
   RC_REQUEST_PARSE_CAP_BYTES,
   RC_SESSIONS_PATH_PREFIX,
+  RC_STREAM_BACKOFF_MS,
   ROUTED_PATH_PREFIX,
+  RcPermissionModeSchema,
+  RcStreamEnvelopeSchema,
+  RcStreamEventSchema,
   UsageError,
   UsageSnapshotError,
   UsageSnapshotSchema,
@@ -9471,8 +10077,13 @@ export {
   collectPoolPick,
   createLeafCache,
   createProfile,
+  createRcApiNodeHandler,
+  createRcApiRouter,
   createRcControlHandler,
+  createRcEventFanout,
   createRcSessionTracker,
+  createRcStreamHub,
+  createSseParser,
   describeProviderEndpoint,
   detectAmbientCredential,
   effectiveWindow,
@@ -9485,6 +10096,7 @@ export {
   formatCheckReport,
   formatDoctorReport,
   forwardableHeaders,
+  frontDoorRcApiClient,
   frontDoorRcControl,
   generateCa,
   identityExists,
@@ -9502,6 +10114,7 @@ export {
   mintLeaf,
   observingRoutedRoute,
   parseConnectTarget,
+  parseRcStreamEnvelope,
   planOf,
   prepareClaudeLaunch,
   prepareLaunch,
@@ -9523,6 +10136,7 @@ export {
   realConnectEffects,
   realRcControlTransport,
   realRcEventDial,
+  realRcStreamDial,
   recoverFarm,
   recoveryDiagnostics,
   removeDirectoryRule,