agent-shim 8.8.0 → 8.9.0

package/dist/index.cjs

@@ -77,11 +77,16 @@ __export(index_exports, {
   ProviderNotFoundError: () => ProviderNotFoundError,
   ProviderSchema: () => ProviderSchema,
   RC_IDLE_EXPIRY_MS: () => RC_IDLE_EXPIRY_MS,
+  RC_ORPC_PATH_PREFIX: () => RC_ORPC_PATH_PREFIX,
   RC_PENDING_DEADLINE_MS: () => RC_PENDING_DEADLINE_MS,
   RC_PERMISSION_MODES: () => RC_PERMISSION_MODES,
   RC_REQUEST_PARSE_CAP_BYTES: () => RC_REQUEST_PARSE_CAP_BYTES,
   RC_SESSIONS_PATH_PREFIX: () => RC_SESSIONS_PATH_PREFIX,
+  RC_STREAM_BACKOFF_MS: () => RC_STREAM_BACKOFF_MS,
   ROUTED_PATH_PREFIX: () => ROUTED_PATH_PREFIX,
+  RcPermissionModeSchema: () => RcPermissionModeSchema,
+  RcStreamEnvelopeSchema: () => RcStreamEnvelopeSchema,
+  RcStreamEventSchema: () => RcStreamEventSchema,
   UsageError: () => UsageError,
   UsageSnapshotError: () => UsageSnapshotError,
   UsageSnapshotSchema: () => UsageSnapshotSchema,
@@ -107,8 +112,13 @@ __export(index_exports, {
   collectPoolPick: () => collectPoolPick,
   createLeafCache: () => createLeafCache,
   createProfile: () => createProfile,
+  createRcApiNodeHandler: () => createRcApiNodeHandler,
+  createRcApiRouter: () => createRcApiRouter,
   createRcControlHandler: () => createRcControlHandler,
+  createRcEventFanout: () => createRcEventFanout,
   createRcSessionTracker: () => createRcSessionTracker,
+  createRcStreamHub: () => createRcStreamHub,
+  createSseParser: () => createSseParser,
   describeProviderEndpoint: () => describeProviderEndpoint,
   detectAmbientCredential: () => detectAmbientCredential,
   effectiveWindow: () => effectiveWindow,
@@ -121,6 +131,7 @@ __export(index_exports, {
   formatCheckReport: () => formatCheckReport,
   formatDoctorReport: () => formatDoctorReport,
   forwardableHeaders: () => forwardableHeaders,
+  frontDoorRcApiClient: () => frontDoorRcApiClient,
   frontDoorRcControl: () => frontDoorRcControl,
   generateCa: () => generateCa,
   identityExists: () => identityExists,
@@ -138,6 +149,7 @@ __export(index_exports, {
   mintLeaf: () => mintLeaf,
   observingRoutedRoute: () => observingRoutedRoute,
   parseConnectTarget: () => parseConnectTarget,
+  parseRcStreamEnvelope: () => parseRcStreamEnvelope,
   planOf: () => planOf,
   prepareClaudeLaunch: () => prepareClaudeLaunch,
   prepareLaunch: () => prepareLaunch,
@@ -159,6 +171,7 @@ __export(index_exports, {
   realConnectEffects: () => realConnectEffects,
   realRcControlTransport: () => realRcControlTransport,
   realRcEventDial: () => realRcEventDial,
+  realRcStreamDial: () => realRcStreamDial,
   recoverFarm: () => recoverFarm,
   recoveryDiagnostics: () => recoveryDiagnostics,
   removeDirectoryRule: () => removeDirectoryRule,
@@ -3267,1326 +3280,1916 @@ function realConnectCertStore(paths) {
 // src/frontdoor/connectEffects.ts
 var import_node_dns = __toESM(require("node:dns"), 1);
 var http = __toESM(require("node:http"), 1);
-var https = __toESM(require("node:https"), 1);
+var https2 = __toESM(require("node:https"), 1);
 var net2 = __toESM(require("node:net"), 1);
 var tls = __toESM(require("node:tls"), 1);
-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
+var https = __toESM(require("node:https"), 1);
+
+// 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;
   }
-  import_node_dns.default.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);
+      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, 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;
+      }
+      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);
+        }
+      };
+    }
+    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;
+      }
+      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 = [];
+          }
+        },
+        onRequestEnd: () => {
+          requestEnded = true;
+          file();
+        }
+      },
+      onResponse: (status, headers) => {
+        if (singleHeader(headers, CONFLICT_REASON_HEADER) !== void 0 || archiving && isSuccessful(status)) {
+          expire(id);
+          return;
+        }
+        accepted = isSuccessful(status);
+        file();
+      },
+      onBodyChunk: () => {
+      },
+      onEnd: () => {
+      }
+    };
+  };
+  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);
+    },
+    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;
+      }
+      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() });
+        }
+        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);
         });
-        response.on("end", () => {
-          resolve({ status: response.statusCode ?? HTTP_BAD_GATEWAY, body: Buffer.concat(chunks).toString("utf8") });
+        request4.body.on("end", () => {
+          observed.onRequestEnd?.();
         });
-      });
-      request4.once("error", reject);
-      request4.end(body);
-    })
+      }
+      await route.serve(request4, observed === void 0 ? response : teeRoutedResponse(response, observed, hooks?.onExchangeSettled));
+    }
   };
 }
-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"));
+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 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();
+    }
+  };
+}
+function buildRcUserMessagePayload(uuid, sessionId, text) {
+  return {
+    type: "user",
+    uuid,
+    session_id: sessionId,
+    parent_tool_use_id: null,
+    message: { role: "user", content: text }
+  };
+}
+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;
+    }
+  }
+  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}` };
+    }
+    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 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 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: rcSessionNotObservedMessage(sessionId) };
+  }
+  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)}` };
+  }
+  const result = rcEventWriteResultFromAnswer(answer);
+  if (result.ok) {
+    deps.noteSequenceNums(sessionId, result.sequenceNums);
+  }
+  return result;
+}
+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) };
+  }
+  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;
+}
+async function interruptRcSession(deps, sessionId) {
+  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(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)}` };
+  }
+  const result = rcEventWriteResultFromAnswer(answer);
+  if (result.ok) {
+    deps.noteSequenceNums(sessionId, result.sequenceNums);
+  }
+  return result;
+}
+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;
       }
-      resolve({
-        port: bound,
-        close: async () => {
-          await new Promise((closeResolve) => {
-            server.close(() => {
-              closeResolve(void 0);
-            });
-            for (const socket of accepted) {
-              socket.destroy();
-            }
-          });
-        }
-      });
+      chunks.push(chunk);
+    });
+    request4.on("end", () => {
+      resolve(Buffer.concat(chunks).toString("utf8"));
+    });
+    request4.on("error", () => {
+      reject(new Error("the request body ended early"));
     });
   });
-  return {
-    listenLoopback: async (preferredPort, onSocket) => {
-      if (preferredPort !== void 0) {
+}
+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;
+      }
+      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: rcSessionNotObservedMessage(session) });
+          return;
+        }
+        answerJson(response, HTTP_STATUS.ok, url.pathname === statusPath ? { statuses: deps.statusOf(session) } : { pending: deps.pendingOf(session) });
+        return;
+      }
+      if (url.pathname === injectPath) {
+        if (request4.method !== "POST") {
+          answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the inject operation is a POST" });
+          return;
+        }
+        let parsed;
         try {
-          return await listenOnce(preferredPort, onSocket);
+          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;
       }
-      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);
+      if (url.pathname === answerPath) {
+        if (request4.method !== "POST") {
+          answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the answer operation is a POST" });
+          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();
+        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;
         }
-      };
-    },
-    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 : "");
+        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;
         }
-      );
-      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();
+        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;
         }
-      };
-    },
-    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 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;
       }
-      return {
-        serve: (socket) => {
-          server.emit("connection", socket);
-        },
-        close: () => {
-          server.close();
-          server.closeAllConnections();
+      if (url.pathname === interruptPath) {
+        if (request4.method !== "POST") {
+          answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the interrupt operation is a POST" });
+          return;
         }
-      };
-    },
-    connectTlsUpstream: async (host, port, clientAlpn) => {
-      const dialled = await reservedDial({ host, port });
-      if (dialled.error !== null) {
-        throw dialled.error;
+        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;
       }
-      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 (url.pathname === setModelPath) {
+        if (request4.method !== "POST") {
+          answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the set-model operation is a POST" });
+          return;
         }
-        if (target.rejectUnauthorized !== void 0) {
-          options.rejectUnauthorized = target.rejectUnauthorized;
+        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 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);
-          });
+      if (url.pathname === setPermissionModePath) {
+        if (request4.method !== "POST") {
+          answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the set-permission-mode operation is a POST" });
+          return;
         }
-        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);
+        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;
         }
-        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?.();
-          });
+        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;
         }
-        response.on("close", () => {
-          observer.onEnd();
-        });
+        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;
       }
-      request4.pipe(upstream);
-      request4.socket.setNoDelay(true);
-      upstream.on("socket", (socket) => {
-        socket.setNoDelay(true);
-      });
-    }
+      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)}` });
+    });
   };
 }
-
-// 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 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 realRcControlTransport(port, ca) {
+  return {
+    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 sessionCreateId(body) {
-  let parsed;
+function controlErrorOf(body) {
   try {
-    parsed = JSON.parse(body);
+    const parsed = JSON.parse(body);
+    if (typeof parsed === "object" && parsed !== null && "error" in parsed && typeof parsed.error === "string") {
+      return parsed.error;
+    }
   } catch {
-    return void 0;
-  }
-  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;
+    return body;
   }
-  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 void 0;
 }
-function parseJsonObject(body) {
-  let parsed;
-  try {
-    parsed = JSON.parse(body);
-  } catch {
-    return void 0;
+function isRcSessionSummary(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
   }
-  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;
-}
-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)}...`;
+  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 payloadEventsOf(body) {
-  const parsed = parseJsonObject(body);
-  const events = parsed === void 0 ? void 0 : parsed.events;
-  if (!Array.isArray(events)) {
-    return [];
+function isRcWorkerFact(value, valueIs) {
+  if (typeof value !== "object" || value === null) {
+    return false;
   }
-  const payloads = [];
-  for (const event of events) {
-    if (!isRecord2(event)) {
-      continue;
-    }
-    const payload = event.payload;
-    if (!isRecord2(payload)) {
-      continue;
-    }
-    payloads.push(payload);
+  if (!("value" in value) || !("observedAt" in value)) {
+    return false;
   }
-  return payloads;
+  return valueIs(value.value) && typeof value.observedAt === "number";
 }
-function pendingOfControlRequestPayload(payload) {
-  if (payload.type !== "control_request") {
-    return void 0;
+function isRcSessionStatus(value) {
+  if (!isRcSessionSummary(value)) {
+    return false;
   }
-  const requestId = nonEmptyString(payload, "request_id") ?? nonEmptyString(payload, "uuid");
-  if (requestId === void 0) {
-    return void 0;
+  if (!("pending" in value) || !Array.isArray(value.pending)) {
+    return false;
   }
-  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 ("workerState" in value && value.workerState !== void 0 && !isRcWorkerFact(value.workerState, (candidate) => typeof candidate === "string")) {
+    return false;
   }
-  return { requestId, type, summary };
+  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 answeredRequestIdsOfControlResponsePayload(payload) {
-  if (payload.type !== "control_response") {
-    return [];
+function isRcPendingRequestSummary(value) {
+  if (typeof value !== "object" || value === null) {
+    return false;
   }
-  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 (!("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 parseRcRequestBody(kind, body) {
-  if (kind === "heartbeat") {
-    return { controlRequests: [], answeredRequestIds: [], idleSeconds: finiteNumber(parseJsonObject(body), "idle_seconds"), workerStatus: void 0 };
+function sequenceNumsOfBody(body) {
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return void 0;
   }
-  if (kind === "worker-registration") {
-    return { controlRequests: [], answeredRequestIds: [], idleSeconds: void 0, workerStatus: nonEmptyString(parseJsonObject(body), "status") };
+  if (typeof parsed !== "object" || parsed === null || !("sequenceNums" in parsed) || !Array.isArray(parsed.sequenceNums)) {
+    return void 0;
   }
-  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;
+  const sequenceNums = [];
+  const values = parsed.sequenceNums;
+  for (const value of values) {
+    if (typeof value !== "number") {
+      return void 0;
     }
-    answeredRequestIds.push(...answeredRequestIdsOfControlResponsePayload(payload));
+    sequenceNums.push(value);
   }
-  return { controlRequests, answeredRequestIds, idleSeconds: void 0, workerStatus: void 0 };
+  return sequenceNums;
 }
-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);
-      }
+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 sweep = () => {
-    for (const [id, entry] of entries) {
-      if (deps.now() - entry.lastSeenAt >= deps.idleMs) {
-        expire(id);
-        continue;
+  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}`);
       }
-      expirePendings(entry, deps.now());
+      sessions.push(value);
     }
+    return sessions;
   };
-  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 statusesOf = (answer, what) => {
+    if (answer.status !== HTTP_STATUS.ok) {
+      throw new Error(`${what} failed (HTTP ${String(answer.status)}): ${controlErrorOf(answer.body) ?? answer.body}`);
     }
-    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);
-        }
-      };
+    let parsed;
+    try {
+      parsed = JSON.parse(answer.body);
+    } catch {
+      throw new Error(`${what}: the door's answer was not JSON: ${answer.body}`);
     }
-    const rest = tail.slice(1);
-    const [id] = rest.split("/");
-    if (id?.startsWith(RC_SESSION_ID_PREFIX) !== true) {
-      return void 0;
+    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 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;
-      }
-      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 = [];
-          }
-        },
-        onRequestEnd: () => {
-          requestEnded = true;
-          file();
-        }
-      },
-      onResponse: (status, headers) => {
-        if (singleHeader(headers, CONFLICT_REASON_HEADER) !== void 0 || archiving && isSuccessful(status)) {
-          expire(id);
-          return;
-        }
-        accepted = isSuccessful(status);
-        file();
-      },
-      onBodyChunk: () => {
-      },
-      onEnd: () => {
+    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}`);
       }
-    };
-  };
-  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);
-    },
-    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);
+      statuses.push(value);
     }
+    return statuses;
   };
-}
-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?.();
-        });
+  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}`);
       }
-      await route.serve(request4, observed === void 0 ? response : teeRoutedResponse(response, observed));
+      pending.push(value);
     }
+    return pending;
   };
-}
-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 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)}` };
     }
-  };
-}
-function rcObserverAsPassthrough(observer) {
-  return {
-    onRequestChunk: (chunk) => {
-      observer.onRequestChunk?.(chunk);
-    },
-    ...observer.onRequestEnd === void 0 ? {} : {
-      onRequestEnd: () => {
-        observer.onRequestEnd?.();
+    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}` };
       }
-    },
-    onResponse: (status, headers) => {
-      observer.onResponse(status, headers);
-    },
-    onResponseChunk: (chunk) => {
-      observer.onBodyChunk(chunk);
-    },
-    onEnd: () => {
-      observer.onEnd();
+      return { ok: true, sequenceNums };
     }
+    return { ok: false, message: describeFailure(answer.status, controlErrorOf(answer.body) ?? answer.body) };
   };
-}
-function buildRcUserMessagePayload(uuid, sessionId, text) {
+  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` };
+
+// src/frontdoor/connectEffects.ts
+var SUCCESS_STATUS_MAX_EXCLUSIVE2 = 300;
+function isSuccessful2(status) {
+  return status >= HTTP_STATUS.ok && status < SUCCESS_STATUS_MAX_EXCLUSIVE2;
 }
-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;
+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 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)}` };
+var realAddressLookup = (host, _options, callback) => {
+  if (net2.isIP(host) !== 0) {
+    callback(null, [{ address: host, family: net2.isIP(host) }]);
+    return;
   }
-  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 } };
+  import_node_dns.default.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 });
+    });
+  });
 }
-function buildRcSetPermissionModePayload(requestId, mode) {
-  return { type: "control_request", request_id: requestId, request: { subtype: "set_permission_mode", mode } };
+function dialTarget(options, defaultPort) {
+  return { host: typeof options.host === "string" ? options.host : "", port: typeof options.port === "number" ? options.port : defaultPort };
 }
-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);
-  }
-  return result;
+function literalDial(target) {
+  return net2.connect({ host: target.host, port: target.port });
 }
-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)}` };
+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);
 }
-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 requestServername(options, fallback) {
+  return "servername" in options && typeof options.servername === "string" && options.servername !== "" ? options.servername : fallback;
 }
-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)` };
+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;
   }
-  if (credential.authorization === void 0) {
-    return noOAuthCredentialResult(sessionId);
+};
+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;
+      }
+      oncreate?.(null, tls.connect({ socket: outcome.socket, servername: requestServername(options, target.host), ...tlsFacts(options) }));
+    });
+    return void 0;
   }
-  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)}` };
+};
+function tlsFacts(options) {
+  const facts = {};
+  if ("ca" in options && Array.isArray(options.ca)) {
+    facts.ca = options.ca;
   }
-  return rcEventWriteResultFromAnswer(answer);
-}
-
-// src/frontdoor/rcControl.ts
-var https2 = __toESM(require("node:https"), 1);
-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);
+  if ("rejectUnauthorized" in options && typeof options.rejectUnauthorized === "boolean") {
+    facts.rejectUnauthorized = options.rejectUnauthorized;
+  }
+  return facts;
 }
-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;
+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];
       }
-      chunks.push(chunk);
-    });
-    request4.on("end", () => {
-      resolve(Buffer.concat(chunks).toString("utf8"));
-    });
-    request4.on("error", () => {
-      reject(new Error("the request body ended early"));
+      if (target.rejectUnauthorized !== void 0) {
+        options.rejectUnauthorized = target.rejectUnauthorized;
+      }
+      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);
+    }
   });
-}
-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 readAll = async (response) => {
+    const chunks = [];
+    for await (const chunk of upstreamChunks(response)) {
+      chunks.push(Buffer.from(chunk));
     }
-    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;
-      }
-      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 (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;
+    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) {
-  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") });
-          });
+
+// src/frontdoor/rcApi.ts
+var import_client = require("@orpc/client");
+var import_fetch = require("@orpc/client/fetch");
+var import_server2 = require("@orpc/server");
+var import_node = require("@orpc/server/node");
+var import_undici = require("undici");
+
+// src/frontdoor/rcSchemas.ts
+var import_zod4 = require("zod");
+var RcPermissionModeSchema = import_zod4.z.enum(RC_PERMISSION_MODES);
+var RcSessionSummarySchema = import_zod4.z.strictObject({
+  id: import_zod4.z.string(),
+  createdAt: import_zod4.z.number(),
+  lastSeenAt: import_zod4.z.number()
+});
+function workerFactSchema(value) {
+  return import_zod4.z.strictObject({ value, observedAt: import_zod4.z.number() });
+}
+var RcPendingRequestSummarySchema = import_zod4.z.strictObject({
+  sessionId: import_zod4.z.string(),
+  requestId: import_zod4.z.string(),
+  type: import_zod4.z.string(),
+  summary: import_zod4.z.string(),
+  observedAt: import_zod4.z.number()
+});
+var RcSessionStatusSchema = import_zod4.z.strictObject({
+  ...RcSessionSummarySchema.shape,
+  workerState: workerFactSchema(import_zod4.z.string()).optional(),
+  workerIdleSeconds: workerFactSchema(import_zod4.z.number()).optional(),
+  pending: import_zod4.z.readonly(import_zod4.z.array(RcPendingRequestSummarySchema))
+});
+var RcStreamEnvelopeSchema = import_zod4.z.looseObject({
+  /** The envelope's own event id, when the host sent one. */
+  event_id: import_zod4.z.string().optional(),
+  /** The envelope's event type, the discriminator a consumer switches on (`control_request`, `user`, and kin). */
+  event_type: import_zod4.z.string(),
+  /** The sequence number the host assigned, the value a resume continues after. */
+  sequence_num: import_zod4.z.int(),
+  /** Who emitted the event (`worker` for the CLI's half, a client id for a client's). */
+  source: import_zod4.z.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: import_zod4.z.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: import_zod4.z.unknown().optional()
+});
+var RcStreamEventSchema = import_zod4.z.strictObject({
+  session: import_zod4.z.string(),
+  envelope: RcStreamEnvelopeSchema
+});
+var RcSessionQuerySchema = import_zod4.z.strictObject({
+  session: import_zod4.z.string().min(1).optional()
+});
+var RcSendInputSchema = import_zod4.z.strictObject({
+  session: import_zod4.z.string().min(1),
+  text: import_zod4.z.string().min(1)
+});
+var RcAnswerInputSchema = import_zod4.z.strictObject({
+  session: import_zod4.z.string().min(1),
+  request: import_zod4.z.string().min(1),
+  approve: import_zod4.z.boolean(),
+  text: import_zod4.z.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 = import_zod4.z.strictObject({
+  session: import_zod4.z.string().min(1)
+});
+var RcSetModelInputSchema = import_zod4.z.strictObject({
+  session: import_zod4.z.string().min(1),
+  model: import_zod4.z.string().min(1)
+});
+var RcSetPermissionModeInputSchema = import_zod4.z.strictObject({
+  session: import_zod4.z.string().min(1),
+  mode: RcPermissionModeSchema
+});
+var RcListOutputSchema = import_zod4.z.strictObject({ sessions: import_zod4.z.readonly(import_zod4.z.array(RcSessionSummarySchema)) });
+var RcStatusOutputSchema = import_zod4.z.strictObject({ statuses: import_zod4.z.readonly(import_zod4.z.array(RcSessionStatusSchema)) });
+var RcPendingOutputSchema = import_zod4.z.strictObject({ pending: import_zod4.z.readonly(import_zod4.z.array(RcPendingRequestSummarySchema)) });
+var RcWriteOutputSchema = import_zod4.z.strictObject({
+  session: import_zod4.z.string(),
+  sequenceNums: import_zod4.z.readonly(import_zod4.z.array(import_zod4.z.number()))
+});
+var RcAnswerOutputSchema = import_zod4.z.strictObject({
+  session: import_zod4.z.string(),
+  request: import_zod4.z.string(),
+  sequenceNums: import_zod4.z.readonly(import_zod4.z.array(import_zod4.z.number()))
+});
+
+// src/frontdoor/rcApi.ts
+var RC_ORPC_PATH_PREFIX = "/__agent-shim/orpc";
+var RC_SUBSCRIBER_BUFFER_EVENTS = 100;
+function createRcApiRouter(deps) {
+  const authed = import_server2.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 import_client.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 import_client.ORPCError("BAD_GATEWAY", { message: result.message });
+    }
+    return result.sequenceNums;
+  };
+  return {
+    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 import_client.ORPCError("NOT_FOUND", { message: rcSessionNotObservedMessage(input.session) });
         }
-      );
-      request4.once("error", reject);
-      if (options.body === void 0) {
-        request4.end();
-      } else {
-        request4.end(options.body);
-      }
-    })
+        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 import_client.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((0, import_server2.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 (0, import_server2.withEventMeta)(event, { id: String(event.envelope.sequence_num) });
+              continue;
+            }
+            await Promise.race([
+              new Promise((resolve) => {
+                wake = resolve;
+              }),
+              ended
+            ]);
+          }
+        } finally {
+          detach();
+        }
+      })
+    }
   };
 }
-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 import_node.RPCHandler(createRcApiRouter(deps), { plugins: [new import_node.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 import_undici.Agent({ connect: { ca } });
+  const link = new import_fetch.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 (0, import_undici.fetch)(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 (0, import_client.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}`);
+  const streamHeaders = (credential) => {
+    const headers = { accept: "text/event-stream" };
+    if (credential.authorization !== void 0) {
+      headers.authorization = credential.authorization;
     }
-    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}`);
+    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();
+    }
   };
 }
 
@@ -4596,31 +5199,31 @@ var import_node_crypto7 = require("node:crypto");
 // src/headroom/state.ts
 var import_node_crypto6 = require("node:crypto");
 var import_node_path8 = __toESM(require("node:path"), 1);
-var import_zod4 = require("zod");
+var import_zod5 = require("zod");
 var HEADROOM_ANTHROPIC_UPSTREAM = "https://api.anthropic.com";
 var HEADROOM_STATE_SCHEMA_VERSION = 2;
-var HeadroomStateSchema = import_zod4.z.strictObject({
+var HeadroomStateSchema = import_zod5.z.strictObject({
   /** The supervisor process owning the daemon. Alive means someone is keeping headroom running. */
-  supervisorPid: import_zod4.z.number().int().positive().optional(),
+  supervisorPid: import_zod5.z.number().int().positive().optional(),
   /** The headroom proxy process itself. Absent while the supervisor is between restarts. */
-  headroomPid: import_zod4.z.number().int().positive().optional(),
+  headroomPid: import_zod5.z.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: import_zod4.z.string().min(1).optional(),
+  socketPath: import_zod5.z.string().min(1).optional(),
   /** The `headroom --version` output of the running install. */
-  version: import_zod4.z.string().optional(),
+  version: import_zod5.z.string().optional(),
   /** Hash of the allowlist the running proxy was started with, so a provider-file change is detected as drift. */
-  allowlistHash: import_zod4.z.string().optional(),
+  allowlistHash: import_zod5.z.string().optional(),
   /** Hash of the token-saving settings the running proxy was started with, so a settings change is detected as drift. */
-  settingsHash: import_zod4.z.string().optional(),
+  settingsHash: import_zod5.z.string().optional(),
   /** The install spec the running install was last installed from, so a `source` config change is detected as drift. */
-  installedSource: import_zod4.z.string().optional(),
+  installedSource: import_zod5.z.string().optional(),
   /** The last fatal error, kept across shutdowns so `headroom status` can explain a daemon that is not running. */
-  lastError: import_zod4.z.string().optional()
+  lastError: import_zod5.z.string().optional()
 });
-var HeadroomSessionSchema = import_zod4.z.strictObject({ pid: import_zod4.z.number().int().positive(), startedAt: import_zod4.z.number(), supervisorPid: import_zod4.z.number().int().positive() });
-var HeadroomLockSchema = import_zod4.z.strictObject({ pid: import_zod4.z.number().int().positive(), at: import_zod4.z.number() });
+var HeadroomSessionSchema = import_zod5.z.strictObject({ pid: import_zod5.z.number().int().positive(), startedAt: import_zod5.z.number(), supervisorPid: import_zod5.z.number().int().positive() });
+var HeadroomLockSchema = import_zod5.z.strictObject({ pid: import_zod5.z.number().int().positive(), at: import_zod5.z.number() });
 function parseJson(raw, schema) {
   if (raw === void 0 || raw.trim() === "") {
     return void 0;
@@ -4800,118 +5403,118 @@ var import_node_path10 = __toESM(require("node:path"), 1);
 var import_node_path9 = __toESM(require("node:path"), 1);
 
 // src/usage/schema.ts
-var import_zod5 = require("zod");
+var import_zod6 = require("zod");
 var USAGE_SCHEMA_VERSION = 1;
-var VersionSchema = import_zod5.z.literal(USAGE_SCHEMA_VERSION);
-var InstantSchema = import_zod5.z.iso.datetime();
-var TokenCountSchema = import_zod5.z.number().int().nonnegative();
-var TokenUsageSchema = import_zod5.z.strictObject({
+var VersionSchema = import_zod6.z.literal(USAGE_SCHEMA_VERSION);
+var InstantSchema = import_zod6.z.iso.datetime();
+var TokenCountSchema = import_zod6.z.number().int().nonnegative();
+var TokenUsageSchema = import_zod6.z.strictObject({
   inputTokens: TokenCountSchema.optional(),
   outputTokens: TokenCountSchema.optional(),
   cacheCreationInputTokens: TokenCountSchema.optional(),
   cacheReadInputTokens: TokenCountSchema.optional()
 });
 var LIMIT_KINDS = ["rate-limited", "quota-exhausted"];
-var LimitClassificationSchema = import_zod5.z.strictObject({
-  kind: import_zod5.z.enum(LIMIT_KINDS),
+var LimitClassificationSchema = import_zod6.z.strictObject({
+  kind: import_zod6.z.enum(LIMIT_KINDS),
   /** Seconds to wait before retrying, from the response's `retry-after`. */
-  retryAfterSeconds: import_zod5.z.number().nonnegative().optional(),
+  retryAfterSeconds: import_zod6.z.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: import_zod5.z.string().optional(),
+  window: import_zod6.z.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: import_zod5.z.array(import_zod5.z.string())
+  evidence: import_zod6.z.array(import_zod6.z.string())
 });
-var UsageRecordSchema = import_zod5.z.strictObject({
+var UsageRecordSchema = import_zod6.z.strictObject({
   schemaVersion: VersionSchema,
   /** When the front door received the request. */
   at: InstantSchema,
   /** The launching identity, when the launch resolved one. */
-  identity: import_zod5.z.string().optional(),
+  identity: import_zod6.z.string().optional(),
   /** `anthropic` for an OAuth session's request to Claude Code's own API, otherwise the provider's name. */
-  provider: import_zod5.z.string(),
+  provider: import_zod6.z.string(),
   /** The launch's session id, generated per launch. */
-  sessionId: import_zod5.z.string().optional(),
+  sessionId: import_zod6.z.string().optional(),
   /** The project the launch ran in (its git repository root), when the launch sent one: headroom launches do. */
-  project: import_zod5.z.string().optional(),
+  project: import_zod6.z.string().optional(),
   /** The front-door route that served the request. */
-  route: import_zod5.z.string(),
-  method: import_zod5.z.string(),
+  route: import_zod6.z.string(),
+  method: import_zod6.z.string(),
   /** The API path as the upstream sees it (`/v1/messages`), without the provider prefix or a query string. */
-  endpoint: import_zod5.z.string(),
+  endpoint: import_zod6.z.string(),
   /** The model the response named. */
-  model: import_zod5.z.string().optional(),
-  status: import_zod5.z.number().int(),
+  model: import_zod6.z.string().optional(),
+  status: import_zod6.z.number().int(),
   /** Milliseconds from the request's arrival to its response head. */
-  latencyMs: import_zod5.z.number().int().nonnegative(),
+  latencyMs: import_zod6.z.number().int().nonnegative(),
   /** Milliseconds from the request's arrival to the end of its response body. */
-  durationMs: import_zod5.z.number().int().nonnegative(),
+  durationMs: import_zod6.z.number().int().nonnegative(),
   /** Whether the client received the whole body. */
-  outcome: import_zod5.z.enum(["completed", "aborted"]),
+  outcome: import_zod6.z.enum(["completed", "aborted"]),
   usage: TokenUsageSchema.optional(),
   /** The response's quota and rate-limit headers, by name (see `isRateLimitHeader`). */
-  rateLimitHeaders: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.string()).optional(),
+  rateLimitHeaders: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.string()).optional(),
   limit: LimitClassificationSchema.optional(),
   /** The upstream's request id (`request-id`), for matching a record to the provider's own logs. */
-  requestId: import_zod5.z.string().optional()
+  requestId: import_zod6.z.string().optional()
 });
-var QuotaWindowSchema = import_zod5.z.strictObject({
+var QuotaWindowSchema = import_zod6.z.strictObject({
   /** The fraction of the window used, as the upstream reports it (0 to 1). */
-  utilization: import_zod5.z.number().nonnegative().optional(),
+  utilization: import_zod6.z.number().nonnegative().optional(),
   resetsAt: InstantSchema.optional(),
   /** The window's own status (`allowed`, `allowed_warning`, `rejected`). */
-  status: import_zod5.z.string().optional()
+  status: import_zod6.z.string().optional()
 });
-var UnifiedRateLimitSchema = import_zod5.z.strictObject({
+var UnifiedRateLimitSchema = import_zod6.z.strictObject({
   /** The overall status: `allowed`, `allowed_warning` or `rejected`. */
-  status: import_zod5.z.string().optional(),
+  status: import_zod6.z.string().optional(),
   fiveHour: QuotaWindowSchema.optional(),
   sevenDay: QuotaWindowSchema.optional(),
   /** The window that currently binds. */
-  representativeClaim: import_zod5.z.string().optional(),
+  representativeClaim: import_zod6.z.string().optional(),
   /** When the binding window resets. */
   resetAt: InstantSchema.optional(),
   /** Whether usage beyond the plan (extra usage) is available: `allowed` or `rejected`. */
-  overageStatus: import_zod5.z.string().optional()
+  overageStatus: import_zod6.z.string().optional()
 });
-var RateLimitStateSchema = import_zod5.z.strictObject({
+var RateLimitStateSchema = import_zod6.z.strictObject({
   observedAt: InstantSchema,
   /** Every quota and rate-limit header on that response, by name. */
-  headers: import_zod5.z.record(import_zod5.z.string(), import_zod5.z.string()),
+  headers: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.string()),
   unified: UnifiedRateLimitSchema.optional()
 });
 var LimitEventSchema = LimitClassificationSchema.extend({
   observedAt: InstantSchema,
-  status: import_zod5.z.number().int()
+  status: import_zod6.z.number().int()
 });
-var ProviderQuotaWindowSchema = import_zod5.z.strictObject({
+var ProviderQuotaWindowSchema = import_zod6.z.strictObject({
   /** What the window measures, in the provider's terms (`tokens`, `tool-calls`). */
-  measures: import_zod5.z.string(),
+  measures: import_zod6.z.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: import_zod5.z.number().int().positive().optional(),
+  periodMs: import_zod6.z.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: import_zod5.z.string().optional(),
+  period: import_zod6.z.string().optional(),
   /** The fraction of the window used (0 to 1). */
-  utilization: import_zod5.z.number().nonnegative(),
+  utilization: import_zod6.z.number().nonnegative(),
   resetsAt: InstantSchema.optional(),
   /** Absolute counts, when the provider reports them for this window. */
-  limit: import_zod5.z.number().nonnegative().optional(),
-  used: import_zod5.z.number().nonnegative().optional(),
-  remaining: import_zod5.z.number().nonnegative().optional()
+  limit: import_zod6.z.number().nonnegative().optional(),
+  used: import_zod6.z.number().nonnegative().optional(),
+  remaining: import_zod6.z.number().nonnegative().optional()
 });
-var ProviderQuotaSchema = import_zod5.z.strictObject({
+var ProviderQuotaSchema = import_zod6.z.strictObject({
   observedAt: InstantSchema,
   /** Which usage endpoint produced it (`z.ai`). */
-  source: import_zod5.z.string(),
+  source: import_zod6.z.string(),
   /** The subscription level the endpoint reports, when it does. */
-  level: import_zod5.z.string().optional(),
-  windows: import_zod5.z.array(ProviderQuotaWindowSchema)
+  level: import_zod6.z.string().optional(),
+  windows: import_zod6.z.array(ProviderQuotaWindowSchema)
 });
-var ProviderUsageStateSchema = import_zod5.z.strictObject({
+var ProviderUsageStateSchema = import_zod6.z.strictObject({
   lastRequestAt: InstantSchema,
-  lastStatus: import_zod5.z.number().int(),
-  lastModel: import_zod5.z.string().optional(),
+  lastStatus: import_zod6.z.number().int(),
+  lastModel: import_zod6.z.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. */
@@ -4919,31 +5522,31 @@ var ProviderUsageStateSchema = import_zod5.z.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 = import_zod5.z.strictObject({
-  accountUuid: import_zod5.z.string().optional(),
-  emailAddress: import_zod5.z.string().optional(),
-  displayName: import_zod5.z.string().optional(),
-  organizationUuid: import_zod5.z.string().optional(),
-  organizationName: import_zod5.z.string().optional(),
-  organizationType: import_zod5.z.string().optional(),
-  organizationRole: import_zod5.z.string().optional(),
-  workspaceRole: import_zod5.z.string().optional(),
-  billingType: import_zod5.z.string().optional(),
-  seatTier: import_zod5.z.string().optional(),
-  organizationRateLimitTier: import_zod5.z.string().optional(),
-  userRateLimitTier: import_zod5.z.string().optional(),
-  hasExtraUsageEnabled: import_zod5.z.boolean().optional(),
-  subscriptionCreatedAt: import_zod5.z.string().optional(),
-  accountCreatedAt: import_zod5.z.string().optional()
+var AccountMetadataSchema = import_zod6.z.strictObject({
+  accountUuid: import_zod6.z.string().optional(),
+  emailAddress: import_zod6.z.string().optional(),
+  displayName: import_zod6.z.string().optional(),
+  organizationUuid: import_zod6.z.string().optional(),
+  organizationName: import_zod6.z.string().optional(),
+  organizationType: import_zod6.z.string().optional(),
+  organizationRole: import_zod6.z.string().optional(),
+  workspaceRole: import_zod6.z.string().optional(),
+  billingType: import_zod6.z.string().optional(),
+  seatTier: import_zod6.z.string().optional(),
+  organizationRateLimitTier: import_zod6.z.string().optional(),
+  userRateLimitTier: import_zod6.z.string().optional(),
+  hasExtraUsageEnabled: import_zod6.z.boolean().optional(),
+  subscriptionCreatedAt: import_zod6.z.string().optional(),
+  accountCreatedAt: import_zod6.z.string().optional()
 });
-var UsageSnapshotSchema = import_zod5.z.strictObject({
+var UsageSnapshotSchema = import_zod6.z.strictObject({
   schemaVersion: VersionSchema,
-  identity: import_zod5.z.string(),
+  identity: import_zod6.z.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: import_zod5.z.record(import_zod5.z.string(), ProviderUsageStateSchema)
+  providers: import_zod6.z.record(import_zod6.z.string(), ProviderUsageStateSchema)
 });
 
 // src/usage/account.ts
@@ -5147,20 +5750,20 @@ function quotaWarnings(snapshot, provider, nowMs) {
 }
 
 // src/usage/plan.ts
-var import_zod6 = require("zod");
-var PlanClassSchema = import_zod6.z.union([
-  import_zod6.z.strictObject({
-    kind: import_zod6.z.literal("subscription"),
+var import_zod7 = require("zod");
+var PlanClassSchema = import_zod7.z.union([
+  import_zod7.z.strictObject({
+    kind: import_zod7.z.literal("subscription"),
     /** The plan's size as a multiple of the smallest subscription tier (Max 5x is 5, Max 20x is 20). */
-    capacity: import_zod6.z.number().positive(),
+    capacity: import_zod7.z.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: import_zod6.z.boolean(),
+    recognised: import_zod7.z.boolean(),
     /** The tier string the classification rests on, when the account had one. */
-    tier: import_zod6.z.string().optional()
+    tier: import_zod7.z.string().optional()
   }),
-  import_zod6.z.strictObject({
-    kind: import_zod6.z.literal("pay-per-use"),
-    tier: import_zod6.z.string().optional()
+  import_zod7.z.strictObject({
+    kind: import_zod7.z.literal("pay-per-use"),
+    tier: import_zod7.z.string().optional()
   })
 ]);
 var TIER_MULTIPLIER = /(?:^|_)(\d+)x$/;
@@ -5229,17 +5832,17 @@ function parseUnifiedRateLimit(headers) {
 }
 
 // src/usage/scan.ts
-var import_zod7 = require("zod");
-var AnthropicUsageSchema = import_zod7.z.looseObject({
-  input_tokens: import_zod7.z.number().int().nonnegative().nullish(),
-  output_tokens: import_zod7.z.number().int().nonnegative().nullish(),
-  cache_creation_input_tokens: import_zod7.z.number().int().nonnegative().nullish(),
-  cache_read_input_tokens: import_zod7.z.number().int().nonnegative().nullish()
+var import_zod8 = require("zod");
+var AnthropicUsageSchema = import_zod8.z.looseObject({
+  input_tokens: import_zod8.z.number().int().nonnegative().nullish(),
+  output_tokens: import_zod8.z.number().int().nonnegative().nullish(),
+  cache_creation_input_tokens: import_zod8.z.number().int().nonnegative().nullish(),
+  cache_read_input_tokens: import_zod8.z.number().int().nonnegative().nullish()
 });
-var ErrorObjectSchema = import_zod7.z.looseObject({
-  type: import_zod7.z.string().optional(),
-  code: import_zod7.z.union([import_zod7.z.string(), import_zod7.z.number()]).optional(),
-  message: import_zod7.z.string().optional()
+var ErrorObjectSchema = import_zod8.z.looseObject({
+  type: import_zod8.z.string().optional(),
+  code: import_zod8.z.union([import_zod8.z.string(), import_zod8.z.number()]).optional(),
+  message: import_zod8.z.string().optional()
 });
 
 // src/usage/middleware.ts
@@ -5399,7 +6002,7 @@ function rankPool(input) {
 
 // src/usage/poolPick.ts
 var import_node_path11 = __toESM(require("node:path"), 1);
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 
 // src/usage/store.ts
 var DAY_MS2 = 864e5;
@@ -5408,10 +6011,10 @@ var USAGE_RETENTION_MS = DAYS_IN_WEEK * DAY_MS2;
 
 // src/usage/poolPick.ts
 var SCHEMA_VERSION = 1;
-var PickEntrySchema = import_zod8.z.strictObject({ identity: import_zod8.z.string().min(1), at: import_zod8.z.iso.datetime() });
-var PicksFileSchema = import_zod8.z.strictObject({
-  schemaVersion: import_zod8.z.literal(SCHEMA_VERSION),
-  picks: import_zod8.z.record(import_zod8.z.string().min(1), PickEntrySchema)
+var PickEntrySchema = import_zod9.z.strictObject({ identity: import_zod9.z.string().min(1), at: import_zod9.z.iso.datetime() });
+var PicksFileSchema = import_zod9.z.strictObject({
+  schemaVersion: import_zod9.z.literal(SCHEMA_VERSION),
+  picks: import_zod9.z.record(import_zod9.z.string().min(1), PickEntrySchema)
 });
 function errorMessage(error) {
   return error instanceof Error ? error.message : String(error);
@@ -5611,33 +6214,33 @@ function collectPoolPick(params) {
 }
 
 // src/usage/pickReportSchema.ts
-var import_zod9 = require("zod");
-var PoolPickCandidateViewSchema = import_zod9.z.strictObject({
-  identity: import_zod9.z.string(),
+var import_zod10 = require("zod");
+var PoolPickCandidateViewSchema = import_zod10.z.strictObject({
+  identity: import_zod10.z.string(),
   /** In pick order: `scored` has usable quota data, `unknown` has none, `pay-per-use` bills by use, `ineligible` is refused right now. */
-  class: import_zod9.z.enum(["scored", "unknown", "pay-per-use", "ineligible"]),
+  class: import_zod10.z.enum(["scored", "unknown", "pay-per-use", "ineligible"]),
   /** Plan-size-weighted remaining quota per hour until its reset; present for `scored` only. */
-  score: import_zod9.z.number().optional(),
+  score: import_zod10.z.number().optional(),
   /** False when the five-hour window would run dry, at the observed pace, before it resets. */
-  feasible: import_zod9.z.boolean(),
+  feasible: import_zod10.z.boolean(),
   /** When an `ineligible` member can be used again, as an ISO instant. */
-  blockedUntil: import_zod9.z.iso.datetime().optional(),
+  blockedUntil: import_zod10.z.iso.datetime().optional(),
   plan: PlanClassSchema,
   /** The facts behind the class and score, in the order they matter. */
-  reasons: import_zod9.z.array(import_zod9.z.string())
+  reasons: import_zod10.z.array(import_zod10.z.string())
 });
-var PoolPickReportSchema = import_zod9.z.strictObject({
-  pool: import_zod9.z.string(),
-  directory: import_zod9.z.string(),
+var PoolPickReportSchema = import_zod10.z.strictObject({
+  pool: import_zod10.z.string(),
+  directory: import_zod10.z.string(),
   /** The member a launch would run as, absent when every member is refused. */
-  pick: import_zod9.z.string().optional(),
-  candidates: import_zod9.z.array(PoolPickCandidateViewSchema),
+  pick: import_zod10.z.string().optional(),
+  candidates: import_zod10.z.array(PoolPickCandidateViewSchema),
   /** Members that name an identity that does not exist; a launch skips them. */
-  missing: import_zod9.z.array(import_zod9.z.string()),
+  missing: import_zod10.z.array(import_zod10.z.string()),
   /** When nothing can be picked, the soonest any member returns. */
-  earliestReturn: import_zod9.z.strictObject({ identity: import_zod9.z.string(), at: import_zod9.z.iso.datetime() }).optional(),
+  earliestReturn: import_zod10.z.strictObject({ identity: import_zod10.z.string(), at: import_zod10.z.iso.datetime() }).optional(),
   /** Why the last-pick record could not be read, when that is the case. */
-  stickyProblem: import_zod9.z.string().optional()
+  stickyProblem: import_zod10.z.string().optional()
 });
 
 // src/headroom/ensure.ts
@@ -5800,10 +6403,10 @@ function pruneStaleHeadroomSockets(fs12, paths, isRunning) {
 }
 
 // src/headroom/source.ts
-var import_zod10 = require("zod");
+var import_zod11 = require("zod");
 var GIT_SPEC_RE = /git\+[^@\s]+(?:@([^\s#]+))?/;
 var COMMIT_SHA_RE = /^[0-9a-f]{40}$/i;
-var DirectUrlSchema = import_zod10.z.object({ vcs_info: import_zod10.z.object({ commit_id: import_zod10.z.string() }) });
+var DirectUrlSchema = import_zod11.z.object({ vcs_info: import_zod11.z.object({ commit_id: import_zod11.z.string() }) });
 function isMovingGitSource(spec) {
   const match = GIT_SPEC_RE.exec(spec);
   if (match === null) {
@@ -6517,11 +7120,11 @@ var import_node_fs5 = __toESM(require("node:fs"), 1);
 var import_node_path17 = __toESM(require("node:path"), 1);
 
 // src/credentialCache.ts
-var import_zod11 = require("zod");
+var import_zod12 = require("zod");
 var MS_PER_UNIT = { s: 1e3, m: 6e4, h: 36e5, d: 864e5 };
-var CachedCredentialSchema = import_zod11.z.strictObject({
-  token: import_zod11.z.string().min(1),
-  fetchedAt: import_zod11.z.number().int().nonnegative(),
+var CachedCredentialSchema = import_zod12.z.strictObject({
+  token: import_zod12.z.string().min(1),
+  fetchedAt: import_zod12.z.number().int().nonnegative(),
   source: CredentialSourceSchema
 });
 function effectiveStore(cache, platform) {
@@ -6787,14 +7390,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) {
@@ -7758,7 +8361,7 @@ function realResolveClaudeBinary(isOwnBinary) {
 
 // src/checkReport.ts
 var import_node_path23 = __toESM(require("node:path"), 1);
-var import_zod12 = require("zod");
+var import_zod13 = require("zod");
 
 // src/cli/bool.ts
 function parseBoolWord(input) {
@@ -7873,9 +8476,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 = import_zod12.z.looseObject({
-  env: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.unknown()).optional(),
-  hooks: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.array(import_zod12.z.unknown())).optional()
+var SettingsSecretsShapeSchema = import_zod13.z.looseObject({
+  env: import_zod13.z.record(import_zod13.z.string(), import_zod13.z.unknown()).optional(),
+  hooks: import_zod13.z.record(import_zod13.z.string(), import_zod13.z.array(import_zod13.z.unknown())).optional()
 });
 function hookCommandCountOf(group) {
   if (typeof group !== "object" || group === null) {
@@ -8169,11 +8772,11 @@ function collectCheckReport(params) {
 // src/claudeShim.ts
 var import_node_fs8 = __toESM(require("node:fs"), 1);
 var import_node_path24 = __toESM(require("node:path"), 1);
-var import_zod13 = require("zod");
-var ClaudeShimStateSchema = import_zod13.z.strictObject({
-  targetPath: import_zod13.z.string().min(1),
-  method: import_zod13.z.enum(["hardlink", "copy"]),
-  installedAtMs: import_zod13.z.number()
+var import_zod14 = require("zod");
+var ClaudeShimStateSchema = import_zod14.z.strictObject({
+  targetPath: import_zod14.z.string().min(1),
+  method: import_zod14.z.enum(["hardlink", "copy"]),
+  installedAtMs: import_zod14.z.number()
 });
 function commandFilename(ownExecutablePath, commandName) {
   return ownExecutablePath.toLowerCase().endsWith(".exe") ? `${commandName}.exe` : commandName;
@@ -8732,9 +9335,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) {
@@ -8762,6 +9367,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;
@@ -8783,6 +9389,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;
@@ -8836,6 +9446,7 @@ function parseLauncherArgv(argv) {
     ...identity === void 0 ? {} : { identity },
     ...configProfile === void 0 ? {} : { configProfile },
     ...provider === void 0 ? {} : { provider },
+    ...native ? { native: true } : {},
     ...booleans,
     categoryFlags,
     shareFlags,
@@ -9545,6 +10156,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 {
@@ -9552,7 +10166,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),
@@ -9643,11 +10257,16 @@ function prepareClaudeLaunch(options) {
   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,
@@ -9673,8 +10292,13 @@ function prepareClaudeLaunch(options) {
   collectPoolPick,
   createLeafCache,
   createProfile,
+  createRcApiNodeHandler,
+  createRcApiRouter,
   createRcControlHandler,
+  createRcEventFanout,
   createRcSessionTracker,
+  createRcStreamHub,
+  createSseParser,
   describeProviderEndpoint,
   detectAmbientCredential,
   effectiveWindow,
@@ -9687,6 +10311,7 @@ function prepareClaudeLaunch(options) {
   formatCheckReport,
   formatDoctorReport,
   forwardableHeaders,
+  frontDoorRcApiClient,
   frontDoorRcControl,
   generateCa,
   identityExists,
@@ -9704,6 +10329,7 @@ function prepareClaudeLaunch(options) {
   mintLeaf,
   observingRoutedRoute,
   parseConnectTarget,
+  parseRcStreamEnvelope,
   planOf,
   prepareClaudeLaunch,
   prepareLaunch,
@@ -9725,6 +10351,7 @@ function prepareClaudeLaunch(options) {
   realConnectEffects,
   realRcControlTransport,
   realRcEventDial,
+  realRcStreamDial,
   recoverFarm,
   recoveryDiagnostics,
   removeDirectoryRule,