agent-shim 8.11.3 → 8.13.0

package/dist/index.cjs

@@ -81,6 +81,13 @@ __export(index_exports, {
   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_SELF_HOST_ENV: () => RC_SELF_HOST_ENV,
+  RC_SELF_HOST_KEEPALIVE_MS: () => RC_SELF_HOST_KEEPALIVE_MS,
+  RC_SELF_HOST_RECORD_DIR: () => RC_SELF_HOST_RECORD_DIR,
+  RC_SELF_HOST_RECORD_FILE: () => RC_SELF_HOST_RECORD_FILE,
+  RC_SELF_HOST_RETENTION_MS: () => RC_SELF_HOST_RETENTION_MS,
+  RC_SELF_HOST_SCOPE_LIST: () => RC_SELF_HOST_SCOPE_LIST,
+  RC_SELF_HOST_WORKER_JWT_TTL_SECONDS: () => RC_SELF_HOST_WORKER_JWT_TTL_SECONDS,
   RC_SESSIONS_PATH_PREFIX: () => RC_SESSIONS_PATH_PREFIX,
   RC_STREAM_BACKOFF_MS: () => RC_STREAM_BACKOFF_MS,
   ROUTED_PATH_PREFIX: () => ROUTED_PATH_PREFIX,
@@ -117,6 +124,7 @@ __export(index_exports, {
   createRcControlHandler: () => createRcControlHandler,
   createRcCredentialStore: () => createRcCredentialStore,
   createRcEventFanout: () => createRcEventFanout,
+  createRcSelfHostSurface: () => createRcSelfHostSurface,
   createRcSessionTracker: () => createRcSessionTracker,
   createRcStreamHub: () => createRcStreamHub,
   createSseParser: () => createSseParser,
@@ -141,6 +149,8 @@ __export(index_exports, {
   isIdentityDirectoryName: () => isIdentityDirectoryName,
   isInterceptedHost: () => isInterceptedHost,
   isRcPermissionMode: () => isRcPermissionMode,
+  lateRcEventDial: () => lateRcEventDial,
+  lateRcStreamDial: () => lateRcStreamDial,
   listDirectoryRules: () => listDirectoryRules,
   listIdentities: () => listIdentities,
   listProfiles: () => listProfiles,
@@ -148,6 +158,7 @@ __export(index_exports, {
   listUsageSnapshots: () => listUsageSnapshots,
   matchBranch: () => matchBranch,
   mintLeaf: () => mintLeaf,
+  mintRcSelfHostCredential: () => mintRcSelfHostCredential,
   observingRoutedRoute: () => observingRoutedRoute,
   parseConnectTarget: () => parseConnectTarget,
   parseRcStreamEnvelope: () => parseRcStreamEnvelope,
@@ -159,6 +170,7 @@ __export(index_exports, {
   rankPool: () => rankPool,
   rcEventWriteResultFromAnswer: () => rcEventWriteResultFromAnswer,
   rcObserverAsPassthrough: () => rcObserverAsPassthrough,
+  rcSelfHostFromEnv: () => rcSelfHostFromEnv,
   readActiveIdentity: () => readActiveIdentity,
   readDirectoryRules: () => readDirectoryRules,
   readFarmManifest: () => readFarmManifest,
@@ -167,6 +179,7 @@ __export(index_exports, {
   readPools: () => readPools,
   readProfile: () => readProfile,
   readProvider: () => readProvider,
+  readRcSelfHostRecord: () => readRcSelfHostRecord,
   readUsageSnapshot: () => readUsageSnapshot,
   realConnectCertStore: () => realConnectCertStore,
   realConnectEffects: () => realConnectEffects,
@@ -190,6 +203,7 @@ __export(index_exports, {
   runCheck: () => runCheck,
   runDoctor: () => runDoctor,
   runFrontDoorSupervisor: () => runFrontDoorSupervisor,
+  runLauncher: () => runLauncher,
   runSupervisor: () => runSupervisor,
   servedByPipeline: () => servedByPipeline,
   setAllowAmbientCredential: () => setAllowAmbientCredential,
@@ -204,6 +218,7 @@ __export(index_exports, {
   setRcSessionModel: () => setRcSessionModel,
   setRcSessionPermissionMode: () => setRcSessionPermissionMode,
   snapshotPath: () => snapshotPath,
+  spawnClaude: () => spawnClaude,
   startConnectServer: () => startConnectServer,
   topLevelNames: () => topLevelNames,
   updateDirectoryRule: () => updateDirectoryRule,
@@ -3030,8 +3045,8 @@ function parseConnectTarget(authority) {
 function isInterceptedHost(host, interceptHosts) {
   return interceptHosts.includes(host);
 }
-function servedByPipeline(path30) {
-  return path30?.startsWith(ROUTED_PATH_PREFIX) === true;
+function servedByPipeline(path31) {
+  return path31?.startsWith(ROUTED_PATH_PREFIX) === true;
 }
 var HOP_BY_HOP_HEADERS = /* @__PURE__ */ new Set([
   "connection",
@@ -3113,14 +3128,17 @@ ${request4.rawHeaders.reduce((accumulated, value, index) => index % 2 === 0 ? `$
     pumpTapSession(socket, async (clientAlpn) => await effects.connectTlsUpstream(host, HTTPS_PORT, clientAlpn), config.capture?.tapStream?.(host), Buffer.from(headText, "utf8"));
   };
   const sessions = config.interceptHosts.map((host) => {
-    if (config.tapHosts.includes(host)) {
+    if (config.tapHosts.includes(host) && !(config.localSurface?.parsesHost(host) ?? false)) {
       const serveSecure2 = (secure) => {
         pumpTapSession(secure, async (clientAlpn) => await effects.connectTlsUpstream(host, HTTPS_PORT, clientAlpn), config.capture?.tapStream?.(host));
       };
       const tlsAcceptor2 = effects.createTlsAcceptor(config.leafFor(host), serveSecure2, TAP_ALPN_PROTOCOLS);
       return { host, serveSecure: serveSecure2, tlsAcceptor: tlsAcceptor2 };
     }
-    const handler = (request4, response) => {
+    const handleHostRequest = async (request4, response) => {
+      if (config.localSurface !== void 0 && await config.localSurface.serve(host, request4, response)) {
+        return;
+      }
       if (host === config.routedHost && servedByPipeline(request4.url)) {
         const tunnelToken = tunnelTokens.get(request4.socket);
         if (tunnelToken !== void 0 && request4.headers[AUTH_HEADER] === void 0) {
@@ -3131,6 +3149,9 @@ ${request4.rawHeaders.reduce((accumulated, value, index) => index % 2 === 0 ? `$
       }
       effects.forwardHttp(config.upstreamFor(host), request4, response, config.capture?.observePassthrough(request4));
     };
+    const handler = (request4, response) => {
+      void handleHostRequest(request4, response);
+    };
     const httpSession = effects.createHttpSession(handler, onUpgrade(host));
     const serveSecure = (secure, capability) => {
       tunnelTokens.set(secure, capability);
@@ -3513,7 +3534,7 @@ function parseRcRequestBody(kind, body) {
     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") };
+    return { controlRequests: [], answeredRequestIds: [], idleSeconds: void 0, workerStatus: nonEmptyString(parseJsonObject(body), "worker_status") };
   }
   const controlRequests = [];
   const answeredRequestIds = [];
@@ -3562,11 +3583,11 @@ function createRcSessionTracker(deps) {
   };
   const observeExchange = (request4) => {
     const method = (request4.method ?? "").toUpperCase();
-    const path30 = new URL(request4.url ?? "/", "http://127.0.0.1").pathname;
-    if (!path30.startsWith(RC_SESSIONS_PATH_PREFIX)) {
+    const path31 = new URL(request4.url ?? "/", "http://127.0.0.1").pathname;
+    if (!path31.startsWith(RC_SESSIONS_PATH_PREFIX)) {
       return void 0;
     }
-    const tail = path30.slice(RC_SESSIONS_PATH_PREFIX.length);
+    const tail = path31.slice(RC_SESSIONS_PATH_PREFIX.length);
     const facts = {
       oauthAuthorization: oauthAuthorizationOf(request4.headers),
       anthropicVersion: singleHeader(request4.headers, "anthropic-version"),
@@ -4327,9 +4348,9 @@ function sequenceNumsOfBody(body) {
 }
 function frontDoorRcControl(transport, token) {
   const headers = { authorization: `Bearer ${token}` };
-  const listAnswerOf = async (path30, what) => {
+  const listAnswerOf = async (path31, what) => {
     try {
-      return await transport.request({ method: "GET", path: path30, headers });
+      return await transport.request({ method: "GET", path: path31, 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 });
     }
@@ -4401,10 +4422,10 @@ function frontDoorRcControl(transport, token) {
     }
     return pending;
   };
-  const writeOf = async (path30, body, describeFailure) => {
+  const writeOf = async (path31, body, describeFailure) => {
     let answer;
     try {
-      answer = await transport.request({ method: "POST", path: path30, headers: { ...headers, "content-type": "application/json" }, body });
+      answer = await transport.request({ method: "POST", path: path31, 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)}` };
     }
@@ -4614,14 +4635,41 @@ var NO_CHUNKS = {
     next: async () => await Promise.resolve({ done: true, value: void 0 })
   })
 };
+function lateRcEventDial(resolve) {
+  let built;
+  const dialFor = () => {
+    const target = resolve();
+    if (built === void 0 || built.for !== target) {
+      built = { for: target, dial: realRcEventDial(target) };
+    }
+    return built.dial;
+  };
+  return {
+    writeEvents: async (sessionId, headers, body) => await dialFor().writeEvents(sessionId, headers, body)
+  };
+}
+function lateRcStreamDial(resolve) {
+  let built;
+  const dialFor = () => {
+    const target = resolve();
+    if (built === void 0 || built.for !== target) {
+      built = { for: target, dial: realRcStreamDial(target) };
+    }
+    return built.dial;
+  };
+  return {
+    announcePresence: async (sessionId, headers, clientId) => await dialFor().announcePresence(sessionId, headers, clientId),
+    openStream: async (sessionId, headers, resume, signal) => await dialFor().openStream(sessionId, headers, resume, signal)
+  };
+}
 function realRcStreamDial(target = { host: CONNECT_INTERCEPT_HOST, port: HTTPS_PORT }) {
   const agent = new ExemptTlsAgent();
-  const request4 = async (method, path30, headers, body, signal) => await new Promise((resolve, reject) => {
+  const request4 = async (method, path31, headers, body, signal) => await new Promise((resolve, reject) => {
     const options = {
       host: target.host,
       port: target.port,
       method,
-      path: path30,
+      path: path31,
       // 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,
@@ -4658,9 +4706,9 @@ function realRcStreamDial(target = { host: CONNECT_INTERCEPT_HOST, port: HTTPS_P
       return { status, body: await readAll(response) };
     },
     openStream: async (sessionId, headers, resume, signal) => {
-      const path30 = resume === void 0 ? `/v1/code/sessions/${encodeURIComponent(sessionId)}/events/stream` : `/v1/code/sessions/${encodeURIComponent(sessionId)}/events/stream?from_sequence_num=${String(resume.fromSequenceNum)}`;
+      const path31 = 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", path30, streamHeaders, void 0, signal);
+      const { status, response } = await request4("GET", path31, streamHeaders, void 0, signal);
       if (!isSuccessful2(status)) {
         await readAll(response);
         return { status, chunks: NO_CHUNKS };
@@ -5355,37 +5403,930 @@ function createRcStreamHub(deps) {
       await deps.sleep(deps.backoffMs);
       retriedUnauthorized = false;
     }
-  };
-  return {
-    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)})`);
-        });
-      }
+  };
+  return {
+    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();
+    }
+  };
+}
+
+// src/frontdoor/rcSelfHost.ts
+var RC_SELF_HOST_ENV = "AGENT_SHIM_FRONTDOOR_RC_SELF_HOST";
+function rcSelfHostFromEnv(env) {
+  return env[RC_SELF_HOST_ENV] === "1";
+}
+var RC_SELF_HOST_SCOPE_LIST = ["user:profile", "user:inference", "user:sessions:claude_code", "user:mcp_servers", "user:file_upload"];
+var RC_SESSIONS_PATH_PREFIX2 = "/v1/code/sessions";
+var RC_COMPAT_SESSIONS_PATH = "/v1/sessions";
+var RC_SESSION_ID_PREFIX2 = "cse_";
+var RC_SELF_HOST_API_BASE_URL = "https://api.anthropic.com";
+var RC_SELF_HOST_OAUTH_HOST = "platform.claude.com";
+var HTTP_CONFLICT = 409;
+var MS_PER_SECOND2 = 1e3;
+var HTTP_SERVICE_UNAVAILABLE = 503;
+var RC_SELF_HOST_WORKER_JWT_TTL_SECONDS = 46800;
+var RC_SELF_HOST_OAUTH_TOKEN_TTL_SECONDS = 3600;
+var RC_SELF_HOST_KEEPALIVE_MS = 15e3;
+var RC_SELF_HOST_RETENTION_MS = 6e5;
+var RC_PRESENCE_REFRESH_SECONDS = 60;
+var RC_SELF_HOST_MAX_BATCH_EVENTS = 100;
+var RC_SELF_HOST_WORKER_EPOCH = 1;
+var RC_STREAM_EVENT_NAME2 = "client_event";
+var RC_SOURCE_WORKER = "worker";
+var RC_SOURCE_CLIENT = "client";
+var CONFLICT_REASON_HEADER2 = "x-ccr-conflict-reason";
+var CONFLICT_REASON_EPOCH_STALE = "epoch_stale";
+function isRecord5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function nonEmptyString2(record, field) {
+  const value = record === void 0 ? void 0 : record[field];
+  return typeof value === "string" && value !== "" ? value : void 0;
+}
+function numberOf(record, field) {
+  const value = record === void 0 ? void 0 : record[field];
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value;
+  }
+  if (typeof value === "string" && /^[0-9]+$/.test(value)) {
+    return Number(value);
+  }
+  return void 0;
+}
+function singleHeader2(headers, name) {
+  const value = headers[name];
+  return typeof value === "string" ? value : void 0;
+}
+function bearerOf(headers) {
+  const presented = singleHeader2(headers, "authorization");
+  if (presented === void 0) {
+    return void 0;
+  }
+  return presented.slice(0, "bearer ".length).toLowerCase() === "bearer " ? presented.slice("bearer ".length) : void 0;
+}
+async function readBody2(request4, capBytes) {
+  return await new Promise((resolve, reject) => {
+    const chunks = [];
+    let total = 0;
+    request4.on("data", (chunk) => {
+      total += chunk.length;
+      if (total > capBytes) {
+        request4.destroy();
+        reject(new Error("body too large"));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    request4.on("end", () => {
+      resolve(Buffer.concat(chunks).toString("utf8"));
+    });
+    request4.on("error", () => {
+      reject(new Error("the request body ended early"));
+    });
+  });
+}
+function parseJsonObject2(body) {
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return void 0;
+  }
+  return isRecord5(parsed) ? parsed : void 0;
+}
+function mintWorkerJwt(randomToken, issuedAt) {
+  const encode = (value) => Buffer.from(JSON.stringify(value), "utf8").toString("base64url");
+  const header = encode({ alg: "HS256", typ: "JWT" });
+  const payload = encode({ exp: Math.floor((issuedAt + RC_SELF_HOST_WORKER_JWT_TTL_SECONDS * MS_PER_SECOND2) / MS_PER_SECOND2), iat: Math.floor(issuedAt / MS_PER_SECOND2) });
+  return `${header}.${payload}.${Buffer.from(randomToken(), "utf8").toString("base64url")}`;
+}
+function growthBookFeatures() {
+  return {
+    tengu_ccr_bridge: { defaultValue: true },
+    tengu_bridge_repl_v2: { defaultValue: true },
+    tengu_bridge_repl_v2_cse_shim_enabled: { defaultValue: true },
+    tengu_bridge_min_version: { defaultValue: { minVersion: "0.0.0" } }
+  };
+}
+function createRcSelfHostSurface(deps) {
+  const sessions = /* @__PURE__ */ new Map();
+  const sweep = () => {
+    const now = deps.now();
+    for (const session of sessions.values()) {
+      while (session.events[0] !== void 0 && now - session.events[0].storedAt > RC_SELF_HOST_RETENTION_MS) {
+        const dropped = session.events.shift();
+        const uuid = dropped === void 0 ? void 0 : nonEmptyString2(dropped.payload, "uuid");
+        if (uuid !== void 0) {
+          session.seenPayloadUuids.delete(uuid);
+        }
+      }
+      if (session.workerStreams.size === 0 && session.clientStreams.size === 0 && now - session.lastTrafficAt > RC_SELF_HOST_RETENTION_MS) {
+        sessions.delete(session.id);
+      }
+    }
+  };
+  const timer = setInterval(sweep, RC_SELF_HOST_RETENTION_MS);
+  timer.unref();
+  const keepalive = setInterval(() => {
+    for (const session of sessions.values()) {
+      for (const sink of [...session.workerStreams, ...session.clientStreams]) {
+        sink.write(": keep-alive\n\n");
+      }
+    }
+  }, RC_SELF_HOST_KEEPALIVE_MS);
+  keepalive.unref();
+  const presentsCredential = (headers) => {
+    const expected = deps.credentialRecord()?.accessToken;
+    const presented = bearerOf(headers);
+    return expected !== void 0 && presented !== void 0 && isLiveCapability(presented, [expected]);
+  };
+  const presentsWorkerJwt = (headers, session) => {
+    const presented = bearerOf(headers);
+    if (presented === void 0) {
+      return false;
+    }
+    for (const minted of session.workerJwts) {
+      if (isLiveCapability(presented, [minted])) {
+        return true;
+      }
+    }
+    return false;
+  };
+  const frameOf = (event) => {
+    const envelope = {
+      event_id: event.eventId,
+      event_type: nonEmptyString2(event.payload, "type") ?? "event",
+      sequence_num: event.sequenceNum,
+      source: event.source,
+      payload: event.payload,
+      created_at: event.createdAt
+    };
+    return `event: ${RC_STREAM_EVENT_NAME2}
+id: ${String(event.sequenceNum)}
+data: ${JSON.stringify(envelope)}
+
+`;
+  };
+  const holdStream = async (session, which, wantsReplay, request4, response) => {
+    const url = new URL(request4.url, "http://127.0.0.1");
+    const cursor = numberOf({ value: url.searchParams.get("from_sequence_num") }, "value") ?? numberOf({ value: singleHeader2(request4.headers, "last-event-id") }, "value");
+    const replay = cursor === void 0 ? [] : session.events.filter((event) => wantsReplay(event) && event.sequenceNum > cursor);
+    response.start(HTTP_STATUS.ok, { "content-type": "text/event-stream", "cache-control": "no-cache" });
+    response.flush();
+    let pending = Promise.resolve();
+    const sink = {
+      write: (frame) => {
+        pending = pending.then(async () => {
+          await response.write(frame);
+        }).catch(() => {
+        });
+      },
+      retire: () => {
+        session[which].delete(sink);
+      }
+    };
+    session[which].add(sink);
+    session.lastTrafficAt = deps.now();
+    for (const event of replay) {
+      sink.write(frameOf(event));
+    }
+    await new Promise((resolve) => {
+      request4.signal.addEventListener("abort", () => {
+        resolve(void 0);
+      }, { once: true });
+    });
+    sink.retire();
+    response.end();
+  };
+  const publish = (session, source, payload) => {
+    const uuid = nonEmptyString2(payload, "uuid");
+    const duplicate = uuid !== void 0 && session.seenPayloadUuids.has(uuid);
+    session.sequenceNum += 1;
+    const event = {
+      sequenceNum: session.sequenceNum,
+      eventId: uuid ?? deps.newUuid(),
+      source,
+      // The one enrichment the real service was observed making on the live rig's stream: the wall-clock instant it took the write. The worker's handler ignores it; the door's own parser forwards it verbatim.
+      payload: source === RC_SOURCE_CLIENT ? { ...payload, server_received_wall_ms: deps.now() } : payload,
+      createdAt: new Date(deps.now()).toISOString(),
+      toWorker: source === RC_SOURCE_CLIENT,
+      storedAt: deps.now()
+    };
+    session.events.push(event);
+    if (uuid !== void 0) {
+      session.seenPayloadUuids.add(uuid);
+    }
+    session.lastTrafficAt = event.storedAt;
+    const frame = frameOf(event);
+    if (event.toWorker) {
+      for (const sink of [...session.workerStreams]) {
+        sink.write(frame);
+      }
+    }
+    for (const sink of [...session.clientStreams]) {
+      sink.write(frame);
+    }
+    return { sequenceNum: event.sequenceNum, eventId: event.eventId, duplicate };
+  };
+  const answerJson2 = async (response, status, body, extraHeaders = {}) => {
+    const text = JSON.stringify(body);
+    response.start(status, { "content-type": "application/json", "content-length": String(Buffer.byteLength(text, "utf8")), ...extraHeaders });
+    await response.write(text);
+    response.end();
+  };
+  const noCredential = async (response) => {
+    await answerJson2(response, HTTP_SERVICE_UNAVAILABLE, { type: "error", error: { type: "api_error", message: "the front door's self-hosted Remote Control surface is on but no credential has been minted for it; run agent-shim frontdoor rc selfhost mint first" } });
+  };
+  const epochStale = async (response) => {
+    await answerJson2(response, HTTP_CONFLICT, { type: "error", error: { type: "api_error", message: "worker_epoch does not match the session's live epoch" } }, { [CONFLICT_REASON_HEADER2]: CONFLICT_REASON_EPOCH_STALE });
+  };
+  const unauthorized = async (response) => {
+    await answerJson2(response, HTTP_STATUS.unauthorized, { type: "error", error: { type: "authentication_error", message: "the self-hosted Remote Control surface did not recognise the presented credential" } });
+  };
+  const serveSessionPath = async (session, tail, request4, response) => {
+    const method = request4.method.toUpperCase();
+    if (session === void 0) {
+      await answerJson2(response, HTTP_STATUS.notFound, { type: "error", error: { type: "api_error", message: "no such Remote Control session on this door" } });
+      return;
+    }
+    session.lastTrafficAt = deps.now();
+    if (tail === "") {
+      if (method !== "GET") {
+        await answerJson2(response, HTTP_STATUS.methodNotAllowed, { type: "error", error: { type: "api_error", message: "the session read is a GET" } });
+        return;
+      }
+      await answerJson2(response, HTTP_STATUS.ok, { session: { id: session.id, title: session.title, created_at: new Date(session.createdAt).toISOString(), status: "active" } });
+      return;
+    }
+    if (tail === "bridge" && method === "POST") {
+      if (!presentsCredential(request4.headers)) {
+        await unauthorized(response);
+        return;
+      }
+      const workerJwt = mintWorkerJwt(deps.randomToken, deps.now());
+      session.workerJwts.add(workerJwt);
+      deps.log?.(`rc selfhost ${session.id}: bridge registration minted a worker credential`);
+      await answerJson2(response, HTTP_STATUS.ok, { worker_jwt: workerJwt, expires_in: RC_SELF_HOST_WORKER_JWT_TTL_SECONDS, api_base_url: RC_SELF_HOST_API_BASE_URL, worker_epoch: RC_SELF_HOST_WORKER_EPOCH });
+      return;
+    }
+    if (tail === "archive" && method === "POST") {
+      if (!presentsCredential(request4.headers)) {
+        await unauthorized(response);
+        return;
+      }
+      for (const sink of [...session.workerStreams, ...session.clientStreams]) {
+        sink.retire();
+      }
+      sessions.delete(session.id);
+      deps.log?.(`rc selfhost ${session.id}: archived at its client's request`);
+      await answerJson2(response, HTTP_STATUS.ok, {});
+      return;
+    }
+    if (tail === "worker" || tail.startsWith("worker/")) {
+      if (!presentsWorkerJwt(request4.headers, session)) {
+        await unauthorized(response);
+        return;
+      }
+      const workerTail = tail === "worker" ? "" : tail.slice("worker/".length);
+      if (workerTail === "" && method === "GET") {
+        await answerJson2(response, HTTP_STATUS.ok, { worker: { external_metadata: session.externalMetadata ?? null } });
+        return;
+      }
+      if (workerTail === "" && method === "PUT") {
+        const body = parseJsonObject2(await readBody2(request4.body, CONTROL_BODY_CAP_BYTES));
+        const claimedEpoch = numberOf(body, "worker_epoch");
+        if (claimedEpoch !== void 0 && claimedEpoch !== RC_SELF_HOST_WORKER_EPOCH) {
+          await epochStale(response);
+          return;
+        }
+        const status = nonEmptyString2(body, "worker_status");
+        if (status !== void 0) {
+          session.workerStatus = status;
+        }
+        if (isRecord5(body?.external_metadata)) {
+          session.externalMetadata = body.external_metadata;
+        }
+        await answerJson2(response, HTTP_STATUS.ok, {});
+        return;
+      }
+      if (workerTail === "register" && method === "POST") {
+        await readBody2(request4.body, CONTROL_BODY_CAP_BYTES);
+        await answerJson2(response, HTTP_STATUS.ok, { worker_epoch: RC_SELF_HOST_WORKER_EPOCH });
+        return;
+      }
+      if (workerTail === "heartbeat" && method === "POST") {
+        await readBody2(request4.body, CONTROL_BODY_CAP_BYTES);
+        await answerJson2(response, HTTP_STATUS.ok, {});
+        return;
+      }
+      if (workerTail === "events" && method === "POST") {
+        const body = parseJsonObject2(await readBody2(request4.body, CONTROL_BODY_CAP_BYTES));
+        const claimedEpoch = numberOf(body, "worker_epoch");
+        if (claimedEpoch !== void 0 && claimedEpoch !== RC_SELF_HOST_WORKER_EPOCH) {
+          await epochStale(response);
+          return;
+        }
+        const events = body?.events;
+        if (!Array.isArray(events) || events.length === 0 || events.length > RC_SELF_HOST_MAX_BATCH_EVENTS) {
+          await answerJson2(response, HTTP_STATUS.badRequest, { type: "error", error: { type: "invalid_request_error", message: `a worker event batch is a non-empty array of at most ${String(RC_SELF_HOST_MAX_BATCH_EVENTS)} events` } });
+          return;
+        }
+        const results = [];
+        for (const event of events) {
+          if (!isRecord5(event) || !isRecord5(event.payload)) {
+            await answerJson2(response, HTTP_STATUS.badRequest, { type: "error", error: { type: "invalid_request_error", message: "every event in a batch is an object carrying one payload object" } });
+            return;
+          }
+          const published = publish(session, RC_SOURCE_WORKER, event.payload);
+          results.push({ event_id: published.eventId, sequence_num: String(published.sequenceNum) });
+        }
+        sweep();
+        await answerJson2(response, HTTP_STATUS.ok, { results });
+        return;
+      }
+      if (workerTail === "events/stream" && method === "GET") {
+        await holdStream(session, "workerStreams", (event) => event.toWorker, request4, response);
+        return;
+      }
+      if (workerTail === "events/delivery" && method === "POST") {
+        await readBody2(request4.body, CONTROL_BODY_CAP_BYTES);
+        await answerJson2(response, HTTP_STATUS.ok, {});
+        return;
+      }
+      if (workerTail === "internal-events" && method === "POST") {
+        const body = parseJsonObject2(await readBody2(request4.body, CONTROL_BODY_CAP_BYTES));
+        const claimedEpoch = numberOf(body, "worker_epoch");
+        if (claimedEpoch !== void 0 && claimedEpoch !== RC_SELF_HOST_WORKER_EPOCH) {
+          await epochStale(response);
+          return;
+        }
+        const events = body?.events;
+        if (!Array.isArray(events)) {
+          await answerJson2(response, HTTP_STATUS.badRequest, { type: "error", error: { type: "invalid_request_error", message: "an internal event batch is an array" } });
+          return;
+        }
+        for (const event of events) {
+          if (isRecord5(event)) {
+            session.internalEvents.push({ cursor: deps.newUuid(), body: event });
+          }
+        }
+        await answerJson2(response, HTTP_STATUS.ok, {});
+        return;
+      }
+      if (workerTail === "internal-events" && method === "GET") {
+        const url = new URL(request4.url, "http://127.0.0.1");
+        const cursor = url.searchParams.get("cursor");
+        const from = cursor === null ? 0 : session.internalEvents.findIndex((event) => event.cursor === cursor) + 1;
+        const page = session.internalEvents.slice(from);
+        await answerJson2(response, HTTP_STATUS.ok, { data: page.map((event) => event.body), next_cursor: page.length === 0 ? void 0 : page[page.length - 1]?.cursor });
+        return;
+      }
+      if (workerTail === "diagnostics" && method === "POST") {
+        await readBody2(request4.body, CONTROL_BODY_CAP_BYTES);
+        await answerJson2(response, HTTP_STATUS.ok, {});
+        return;
+      }
+      await answerJson2(response, HTTP_STATUS.notFound, { type: "error", error: { type: "api_error", message: `the self-hosted Remote Control surface serves no worker path "${workerTail}"` } });
+      return;
+    }
+    if (!presentsCredential(request4.headers)) {
+      await unauthorized(response);
+      return;
+    }
+    if (tail === "events" && method === "POST") {
+      const body = parseJsonObject2(await readBody2(request4.body, CONTROL_BODY_CAP_BYTES));
+      const events = body?.events;
+      if (!Array.isArray(events) || events.length === 0 || events.length > RC_SELF_HOST_MAX_BATCH_EVENTS) {
+        await answerJson2(response, HTTP_STATUS.badRequest, { type: "error", error: { type: "invalid_request_error", message: `a client event write is a non-empty array of at most ${String(RC_SELF_HOST_MAX_BATCH_EVENTS)} events` } });
+        return;
+      }
+      const results = [];
+      for (const event of events) {
+        if (!isRecord5(event) || !isRecord5(event.payload)) {
+          await answerJson2(response, HTTP_STATUS.badRequest, { type: "error", error: { type: "invalid_request_error", message: "every event in a write is an object carrying one payload object" } });
+          return;
+        }
+        const published = publish(session, RC_SOURCE_CLIENT, event.payload);
+        results.push({ sequence_num: String(published.sequenceNum), duplicate: published.duplicate });
+      }
+      sweep();
+      await answerJson2(response, HTTP_STATUS.ok, { results });
+      return;
+    }
+    if (tail === "events" && method === "GET") {
+      await answerJson2(response, HTTP_STATUS.ok, { data: session.events.map((event) => ({ event_id: event.eventId, event_type: nonEmptyString2(event.payload, "type") ?? "event", sequence_num: event.sequenceNum, source: event.source, payload: event.payload, created_at: event.createdAt })) });
+      return;
+    }
+    if (tail === "events/stream" && method === "GET") {
+      await holdStream(session, "clientStreams", () => true, request4, response);
+      return;
+    }
+    if (tail === "client/presence" && method === "POST") {
+      await readBody2(request4.body, CONTROL_BODY_CAP_BYTES);
+      await answerJson2(response, HTTP_STATUS.ok, { refresh_after_seconds: RC_PRESENCE_REFRESH_SECONDS });
+      return;
+    }
+    if (tail === "mark_read" && method === "POST") {
+      await readBody2(request4.body, CONTROL_BODY_CAP_BYTES);
+      await answerJson2(response, HTTP_STATUS.ok, {});
+      return;
+    }
+    if (tail === "teleport-events" && method === "POST") {
+      await readBody2(request4.body, CONTROL_BODY_CAP_BYTES);
+      await answerJson2(response, HTTP_STATUS.ok, {});
+      return;
+    }
+    await answerJson2(response, HTTP_STATUS.notFound, { type: "error", error: { type: "api_error", message: `the self-hosted Remote Control surface serves no path "${tail}"` } });
+  };
+  const recordMissing = () => deps.credentialRecord() === void 0;
+  const route = {
+    name: "rc-selfhost",
+    headroomEligible: false,
+    headroomUpstream: void 0,
+    serve: async (request4, response) => {
+      const method = request4.method.toUpperCase();
+      const pathname = new URL(request4.url, "http://127.0.0.1").pathname;
+      if (recordMissing()) {
+        await noCredential(response);
+        return;
+      }
+      if (pathname === RC_COMPAT_SESSIONS_PATH) {
+        if (method !== "GET") {
+          await answerJson2(response, HTTP_STATUS.methodNotAllowed, { type: "error", error: { type: "api_error", message: "the compatibility session list is a GET" } });
+          return;
+        }
+        if (!presentsCredential(request4.headers)) {
+          await unauthorized(response);
+          return;
+        }
+        await answerJson2(response, HTTP_STATUS.ok, { data: [] });
+        return;
+      }
+      if (pathname !== RC_SESSIONS_PATH_PREFIX2 && !pathname.startsWith(`${RC_SESSIONS_PATH_PREFIX2}/`)) {
+        await answerJson2(response, HTTP_STATUS.notFound, { type: "error", error: { type: "api_error", message: `the self-hosted Remote Control surface serves no path "${pathname}"` } });
+        return;
+      }
+      if (pathname === RC_SESSIONS_PATH_PREFIX2) {
+        if (method === "POST") {
+          if (!presentsCredential(request4.headers)) {
+            await unauthorized(response);
+            return;
+          }
+          const body = parseJsonObject2(await readBody2(request4.body, CONTROL_BODY_CAP_BYTES));
+          const session = {
+            id: `${RC_SESSION_ID_PREFIX2}${deps.newUuid()}`,
+            createdAt: deps.now(),
+            title: nonEmptyString2(body, "title"),
+            workerJwts: /* @__PURE__ */ new Set(),
+            sequenceNum: 0,
+            events: [],
+            seenPayloadUuids: /* @__PURE__ */ new Set(),
+            workerStreams: /* @__PURE__ */ new Set(),
+            clientStreams: /* @__PURE__ */ new Set(),
+            internalEvents: [],
+            workerStatus: void 0,
+            externalMetadata: void 0,
+            lastTrafficAt: deps.now()
+          };
+          sessions.set(session.id, session);
+          deps.log?.(`rc selfhost ${session.id}: session created on the door's own surface`);
+          await answerJson2(response, HTTP_STATUS.ok, { session: { id: session.id, title: session.title, created_at: new Date(session.createdAt).toISOString(), status: "active" } });
+          return;
+        }
+        if (method === "GET") {
+          if (!presentsCredential(request4.headers)) {
+            await unauthorized(response);
+            return;
+          }
+          await answerJson2(response, HTTP_STATUS.ok, { data: [...sessions.values()].map((session) => ({ id: session.id, title: session.title, created_at: new Date(session.createdAt).toISOString(), updated_at: new Date(session.lastTrafficAt).toISOString(), session_status: "active" })) });
+          return;
+        }
+        await answerJson2(response, HTTP_STATUS.methodNotAllowed, { type: "error", error: { type: "api_error", message: "the session collection is a POST (create) and a GET (list)" } });
+        return;
+      }
+      const rest = pathname.slice(`${RC_SESSIONS_PATH_PREFIX2}/`.length);
+      const slash = rest.indexOf("/");
+      const id = slash === -1 ? rest : rest.slice(0, slash);
+      const tail = slash === -1 ? "" : rest.slice(slash + 1);
+      if (!id.startsWith(RC_SESSION_ID_PREFIX2)) {
+        await answerJson2(response, HTTP_STATUS.notFound, { type: "error", error: { type: "api_error", message: "the session family names one cse_-prefixed session id" } });
+        return;
+      }
+      await serveSessionPath(sessions.get(id), tail, request4, response);
+    }
+  };
+  const answerServerJson = (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);
+  };
+  const local = {
+    parsesHost: (host) => host === RC_SELF_HOST_OAUTH_HOST,
+    serve: async (host, request4, response) => {
+      const method = (request4.method ?? "").toUpperCase();
+      const pathname = new URL(request4.url ?? "/", "http://127.0.0.1").pathname;
+      if (host === RC_SELF_HOST_OAUTH_HOST) {
+        if (method === "POST" && pathname === "/v1/oauth/token") {
+          const body = parseJsonObject2(await readBody2(request4, CONTROL_BODY_CAP_BYTES));
+          const record = deps.credentialRecord();
+          if (record === void 0) {
+            answerServerJson(response, HTTP_SERVICE_UNAVAILABLE, { error: "the front door's self-hosted Remote Control surface is on but no credential has been minted for it" });
+            return true;
+          }
+          if (body?.grant_type !== void 0 && body.grant_type !== "refresh_token") {
+            answerServerJson(response, HTTP_STATUS.badRequest, { error: "unsupported_grant_type" });
+            return true;
+          }
+          answerServerJson(response, HTTP_STATUS.ok, { access_token: record.accessToken, refresh_token: record.refreshToken, expires_in: RC_SELF_HOST_OAUTH_TOKEN_TTL_SECONDS, scope: RC_SELF_HOST_SCOPE_LIST.join(" ") });
+          return true;
+        }
+        if (method === "GET" && pathname === "/v1/oauth/hello") {
+          answerServerJson(response, HTTP_STATUS.ok, {});
+          return true;
+        }
+        return false;
+      }
+      if (method === "POST" && pathname.startsWith("/api/eval/")) {
+        await readBody2(request4, CONTROL_BODY_CAP_BYTES);
+        answerServerJson(response, HTTP_STATUS.ok, { features: growthBookFeatures(), dateUpdated: Math.floor(deps.now() / MS_PER_SECOND2) });
+        return true;
+      }
+      if (method === "GET" && pathname === "/api/oauth/profile") {
+        const record = deps.credentialRecord();
+        if (record === void 0) {
+          answerServerJson(response, HTTP_SERVICE_UNAVAILABLE, { error: "the front door's self-hosted Remote Control surface is on but no credential has been minted for it" });
+          return true;
+        }
+        answerServerJson(response, HTTP_STATUS.ok, {
+          account: { uuid: record.accountUuid, display_name: "agent-shim self-hosted", created_at: (/* @__PURE__ */ new Date(0)).toISOString() },
+          organization: { uuid: record.organizationUuid, organization_type: "claude_max" }
+        });
+        return true;
+      }
+      if (method === "GET" && pathname === "/api/claude_code/policy_limits") {
+        answerServerJson(response, HTTP_STATUS.ok, {});
+        return true;
+      }
+      if (method === "POST" && pathname === "/api/oauth/validate") {
+        await readBody2(request4, CONTROL_BODY_CAP_BYTES);
+        const record = deps.credentialRecord();
+        if (record === void 0) {
+          answerServerJson(response, HTTP_SERVICE_UNAVAILABLE, { error: "the front door's self-hosted Remote Control surface is on but no credential has been minted for it" });
+          return true;
+        }
+        answerServerJson(response, HTTP_STATUS.ok, { scopes: [...RC_SELF_HOST_SCOPE_LIST], expiresAt: null, subscriptionType: "max", account_uuid: record.accountUuid, organization_uuid: record.organizationUuid });
+        return true;
+      }
+      if (method === "POST" && (pathname === "/api/event_logging/v2/batch" || pathname === "/api/claude_code/metrics" || pathname === "/api/claude_cli_feedback")) {
+        await readBody2(request4, CONTROL_BODY_CAP_BYTES);
+        answerServerJson(response, HTTP_STATUS.ok, {});
+        return true;
+      }
+      if (method === "GET" && pathname === "/api/hello") {
+        answerServerJson(response, HTTP_STATUS.ok, {});
+        return true;
+      }
+      return false;
+    }
+  };
+  return {
+    route,
+    local,
+    close: () => {
+      clearInterval(timer);
+      clearInterval(keepalive);
+      for (const session of sessions.values()) {
+        for (const sink of [...session.workerStreams, ...session.clientStreams]) {
+          sink.retire();
+        }
+      }
+      sessions.clear();
+    }
+  };
+}
+
+// src/frontdoor/rcSelfHostMint.ts
+var import_node_path11 = __toESM(require("node:path"), 1);
+
+// src/usage/account.ts
+var import_node_path10 = __toESM(require("node:path"), 1);
+
+// src/usage/schema.ts
+var import_zod5 = 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({
+  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),
+  /** Seconds to wait before retrying, from the response's `retry-after`. */
+  retryAfterSeconds: import_zod5.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(),
+  /** 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())
+});
+var UsageRecordSchema = import_zod5.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(),
+  /** `anthropic` for an OAuth session's request to Claude Code's own API, otherwise the provider's name. */
+  provider: import_zod5.z.string(),
+  /** The launch's session id, generated per launch. */
+  sessionId: import_zod5.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(),
+  /** The front-door route that served the request. */
+  route: import_zod5.z.string(),
+  method: import_zod5.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(),
+  /** The model the response named. */
+  model: import_zod5.z.string().optional(),
+  status: import_zod5.z.number().int(),
+  /** Milliseconds from the request's arrival to its response head. */
+  latencyMs: import_zod5.z.number().int().nonnegative(),
+  /** Milliseconds from the request's arrival to the end of its response body. */
+  durationMs: import_zod5.z.number().int().nonnegative(),
+  /** Whether the client received the whole body. */
+  outcome: import_zod5.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(),
+  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()
+});
+var QuotaWindowSchema = import_zod5.z.strictObject({
+  /** The fraction of the window used, as the upstream reports it (0 to 1). */
+  utilization: import_zod5.z.number().nonnegative().optional(),
+  resetsAt: InstantSchema.optional(),
+  /** The window's own status (`allowed`, `allowed_warning`, `rejected`). */
+  status: import_zod5.z.string().optional()
+});
+var UnifiedRateLimitSchema = import_zod5.z.strictObject({
+  /** The overall status: `allowed`, `allowed_warning` or `rejected`. */
+  status: import_zod5.z.string().optional(),
+  fiveHour: QuotaWindowSchema.optional(),
+  sevenDay: QuotaWindowSchema.optional(),
+  /** The window that currently binds. */
+  representativeClaim: import_zod5.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()
+});
+var RateLimitStateSchema = import_zod5.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()),
+  unified: UnifiedRateLimitSchema.optional()
+});
+var LimitEventSchema = LimitClassificationSchema.extend({
+  observedAt: InstantSchema,
+  status: import_zod5.z.number().int()
+});
+var ProviderQuotaWindowSchema = import_zod5.z.strictObject({
+  /** What the window measures, in the provider's terms (`tokens`, `tool-calls`). */
+  measures: import_zod5.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(),
+  /** 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(),
+  /** The fraction of the window used (0 to 1). */
+  utilization: import_zod5.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()
+});
+var ProviderQuotaSchema = import_zod5.z.strictObject({
+  observedAt: InstantSchema,
+  /** Which usage endpoint produced it (`z.ai`). */
+  source: import_zod5.z.string(),
+  /** The subscription level the endpoint reports, when it does. */
+  level: import_zod5.z.string().optional(),
+  windows: import_zod5.z.array(ProviderQuotaWindowSchema)
+});
+var ProviderUsageStateSchema = import_zod5.z.strictObject({
+  lastRequestAt: InstantSchema,
+  lastStatus: import_zod5.z.number().int(),
+  lastModel: import_zod5.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. */
+  lastLimit: LimitEventSchema.optional(),
+  /** 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 UsageSnapshotSchema = import_zod5.z.strictObject({
+  schemaVersion: VersionSchema,
+  identity: import_zod5.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)
+});
+
+// src/usage/account.ts
+var CLAUDE_JSON = ".claude.json";
+var AccountMetadataError = class extends CliError {
+  constructor(file, detail) {
+    super(`${file}: ${detail}, so its account metadata cannot be read.`);
+    this.file = file;
+    this.name = "AccountMetadataError";
+  }
+  file;
+};
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isIdentityName(name) {
+  return IdentitySchema.shape.name.safeParse(name).success;
+}
+function claudeJsonPath(identitiesDir, identity) {
+  return import_node_path10.default.join(identitiesDir, identity, CLAUDE_JSON);
+}
+function readAccountMetadata(fs12, identitiesDir, identity) {
+  if (!isIdentityName(identity)) {
+    throw new Error(`"${identity}" is not a valid identity name.`);
+  }
+  const file = claudeJsonPath(identitiesDir, identity);
+  const raw = fs12.readFileUtf8(file);
+  if (raw === void 0) {
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new AccountMetadataError(file, "not valid JSON");
+  }
+  if (!isObject(parsed)) {
+    throw new AccountMetadataError(file, "not a JSON object");
+  }
+  const oauthAccount = parsed.oauthAccount;
+  if (!isObject(oauthAccount)) {
+    return void 0;
+  }
+  const picked = {};
+  for (const key of Object.keys(AccountMetadataSchema.shape)) {
+    const value = oauthAccount[key];
+    if (value !== null && value !== void 0) {
+      picked[key] = value;
+    }
+  }
+  const account = AccountMetadataSchema.safeParse(picked);
+  if (!account.success) {
+    throw new AccountMetadataError(file, account.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; "));
+  }
+  return account.data;
+}
+
+// src/frontdoor/rcSelfHostMint.ts
+var CREDENTIALS_FILE = ".credentials.json";
+var CLAUDE_JSON2 = ".claude.json";
+var RC_SELF_HOST_RECORD_DIR = "rc-selfhost";
+var RC_SELF_HOST_RECORD_FILE = "credential.json";
+var SELF_HOST_EMAIL = "selfhost@agent-shim.invalid";
+var SELF_HOST_SUBSCRIPTION_TYPE = "max";
+function isRecord6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readJsonObject(fs12, file) {
+  const raw = fs12.readFileUtf8(file);
+  if (raw === void 0) {
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+  return isRecord6(parsed) ? parsed : void 0;
+}
+function readRcSelfHostRecord(fs12, frontdoorDir) {
+  const parsed = readJsonObject(fs12, import_node_path11.default.join(frontdoorDir, RC_SELF_HOST_RECORD_DIR, RC_SELF_HOST_RECORD_FILE));
+  if (parsed === void 0) {
+    return void 0;
+  }
+  const { accessToken, refreshToken, organizationUuid, accountUuid } = parsed;
+  if (typeof accessToken !== "string" || accessToken === "" || typeof refreshToken !== "string" || refreshToken === "" || typeof organizationUuid !== "string" || organizationUuid === "" || typeof accountUuid !== "string" || accountUuid === "") {
+    return void 0;
+  }
+  return { accessToken, refreshToken, organizationUuid, accountUuid };
+}
+function mintRcSelfHostCredential(deps) {
+  if (!isIdentityName(deps.identity)) {
+    throw new Error(`"${deps.identity}" is not a valid identity name.`);
+  }
+  const identityDir = import_node_path11.default.join(deps.identitiesDir, deps.identity);
+  const credentialsFile = import_node_path11.default.join(identityDir, CREDENTIALS_FILE);
+  const claudeJsonFile = import_node_path11.default.join(identityDir, CLAUDE_JSON2);
+  const recordDir = import_node_path11.default.join(deps.frontdoorDir, RC_SELF_HOST_RECORD_DIR);
+  const recordFile = import_node_path11.default.join(recordDir, RC_SELF_HOST_RECORD_FILE);
+  const previousRecord = readRcSelfHostRecord(deps.fs, deps.frontdoorDir);
+  const existingCredentials = readJsonObject(deps.fs, credentialsFile);
+  const existingOauth = isRecord6(existingCredentials?.claudeAiOauth) ? existingCredentials.claudeAiOauth : void 0;
+  const existingToken = typeof existingOauth?.accessToken === "string" && existingOauth.accessToken !== "" ? existingOauth.accessToken : void 0;
+  const existingIsOwn = existingToken !== void 0 && previousRecord?.accessToken === existingToken;
+  if (existingToken !== void 0 && !existingIsOwn && !deps.force) {
+    throw new Error(
+      `identity ${deps.identity} already holds an OAuth credential this door did not mint (a real claude.ai login): pass --force to replace it, or mint into an identity with no login. The self-hosted mode expects no Anthropic credential to be in play.`
+    );
+  }
+  const accessToken = `sk-ant-oat${deps.randomToken()}`;
+  const refreshToken = deps.randomToken();
+  const organizationUuid = deps.newUuid();
+  const accountUuid = deps.newUuid();
+  const mintedAt = new Date(deps.now()).toISOString();
+  deps.fs.mkdirPrivate(import_node_path11.default.dirname(credentialsFile));
+  deps.fs.writeFilePrivate(credentialsFile, `${JSON.stringify({ ...existingCredentials, claudeAiOauth: { accessToken, refreshToken, expiresAt: null, scopes: [...RC_SELF_HOST_SCOPE_LIST], subscriptionType: SELF_HOST_SUBSCRIPTION_TYPE, rateLimitTier: null } }, null, 2)}
+`);
+  const claudeJson = readJsonObject(deps.fs, claudeJsonFile) ?? {};
+  const existingBlock = (value) => isRecord6(value) ? value : {};
+  deps.fs.writeFilePrivate(claudeJsonFile, `${JSON.stringify({
+    ...claudeJson,
+    oauthAccount: {
+      ...existingBlock(claudeJson.oauthAccount),
+      accountUuid,
+      emailAddress: SELF_HOST_EMAIL,
+      organizationUuid,
+      organizationName: "agent-shim self-hosted",
+      // The billing and creation fields exist so the CLI's "populate the account block if it is missing" step finds a complete block and skips its profile fetch; the door answers that fetch locally anyway, so these are the quiet path, not a load-bearing claim.
+      billingType: "stripe_subscription",
+      accountCreatedAt: mintedAt,
+      subscriptionCreatedAt: mintedAt
     },
-    close: () => {
-      for (const attachment of attachments.values()) {
-        attachment.stop();
-      }
-      attachments.clear();
+    cachedGrowthBookFeatures: {
+      ...existingBlock(claudeJson.cachedGrowthBookFeatures),
+      tengu_ccr_bridge: true,
+      tengu_bridge_repl_v2: true,
+      tengu_bridge_repl_v2_cse_shim_enabled: true
     }
-  };
+  }, null, 2)}
+`);
+  deps.fs.mkdirPrivate(recordDir);
+  deps.fs.writeFilePrivate(recordFile, `${JSON.stringify({ accessToken, refreshToken, organizationUuid, accountUuid }, null, 2)}
+`);
+  return { identity: deps.identity, organizationUuid, credentialsFile, claudeJsonFile, recordFile, replaced: existingIsOwn };
 }
 
 // src/frontdoor/ensure.ts
@@ -5393,32 +6334,32 @@ var import_node_crypto7 = require("node:crypto");
 
 // src/headroom/state.ts
 var import_node_crypto6 = require("node:crypto");
-var import_node_path10 = __toESM(require("node:path"), 1);
-var import_zod5 = require("zod");
+var import_node_path12 = __toESM(require("node:path"), 1);
+var import_zod6 = require("zod");
 var HEADROOM_ANTHROPIC_UPSTREAM = "https://api.anthropic.com";
 var HEADROOM_STATE_SCHEMA_VERSION = 2;
-var HeadroomStateSchema = import_zod5.z.strictObject({
+var HeadroomStateSchema = import_zod6.z.strictObject({
   /** The supervisor process owning the daemon. Alive means someone is keeping headroom running. */
-  supervisorPid: import_zod5.z.number().int().positive().optional(),
+  supervisorPid: import_zod6.z.number().int().positive().optional(),
   /** The headroom proxy process itself. Absent while the supervisor is between restarts. */
-  headroomPid: import_zod5.z.number().int().positive().optional(),
+  headroomPid: import_zod6.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_zod5.z.string().min(1).optional(),
+  socketPath: import_zod6.z.string().min(1).optional(),
   /** The `headroom --version` output of the running install. */
-  version: import_zod5.z.string().optional(),
+  version: import_zod6.z.string().optional(),
   /** Hash of the allowlist the running proxy was started with, so a provider-file change is detected as drift. */
-  allowlistHash: import_zod5.z.string().optional(),
+  allowlistHash: import_zod6.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_zod5.z.string().optional(),
+  settingsHash: import_zod6.z.string().optional(),
   /** The install spec the running install was last installed from, so a `source` config change is detected as drift. */
-  installedSource: import_zod5.z.string().optional(),
+  installedSource: import_zod6.z.string().optional(),
   /** The last fatal error, kept across shutdowns so `headroom status` can explain a daemon that is not running. */
-  lastError: import_zod5.z.string().optional()
+  lastError: import_zod6.z.string().optional()
 });
-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() });
+var HeadroomSessionSchema = import_zod6.z.strictObject({ pid: import_zod6.z.number().int().positive(), startedAt: import_zod6.z.number(), supervisorPid: import_zod6.z.number().int().positive() });
+var HeadroomLockSchema = import_zod6.z.strictObject({ pid: import_zod6.z.number().int().positive(), at: import_zod6.z.number() });
 function parseJson(raw, schema) {
   if (raw === void 0 || raw.trim() === "") {
     return void 0;
@@ -5434,7 +6375,7 @@ function readHeadroomState(fs12, stateFile) {
   }
 }
 function writeHeadroomState(fs12, stateFile, state) {
-  fs12.mkdirp(import_node_path10.default.dirname(stateFile));
+  fs12.mkdirp(import_node_path12.default.dirname(stateFile));
   fs12.writeFilePrivate(stateFile, `${JSON.stringify(state, null, 2)}
 `);
 }
@@ -5462,7 +6403,7 @@ function readAllProviders(fs12, providersDir) {
       continue;
     }
     try {
-      const parsed = parseJson(fs12.readFileUtf8(import_node_path10.default.join(providersDir, name)), ProviderSchema);
+      const parsed = parseJson(fs12.readFileUtf8(import_node_path12.default.join(providersDir, name)), ProviderSchema);
       if (parsed !== void 0) {
         result.push({ name: name.slice(0, -".json".length), provider: parsed });
       }
@@ -5474,11 +6415,11 @@ function readAllProviders(fs12, providersDir) {
 }
 function writeSession(fs12, sessionsDir, session) {
   fs12.mkdirp(sessionsDir);
-  fs12.writeFileUtf8(import_node_path10.default.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
+  fs12.writeFileUtf8(import_node_path12.default.join(sessionsDir, `${String(session.pid)}.json`), `${JSON.stringify(session, null, 2)}
 `);
 }
 function removeSession(fs12, sessionsDir, pid) {
-  fs12.removeRecursive(import_node_path10.default.join(sessionsDir, `${String(pid)}.json`));
+  fs12.removeRecursive(import_node_path12.default.join(sessionsDir, `${String(pid)}.json`));
 }
 function listSessions(fs12, sessionsDir) {
   const sessions = [];
@@ -5487,7 +6428,7 @@ function listSessions(fs12, sessionsDir) {
       continue;
     }
     try {
-      const parsed = parseJson(fs12.readFileUtf8(import_node_path10.default.join(sessionsDir, name)), HeadroomSessionSchema);
+      const parsed = parseJson(fs12.readFileUtf8(import_node_path12.default.join(sessionsDir, name)), HeadroomSessionSchema);
       if (parsed !== void 0) {
         sessions.push(parsed);
       }
@@ -5592,214 +6533,7 @@ function ensureFrontDoor(params) {
 }
 
 // src/usage/read.ts
-var import_node_path12 = __toESM(require("node:path"), 1);
-
-// src/usage/account.ts
-var import_node_path11 = __toESM(require("node:path"), 1);
-
-// src/usage/schema.ts
-var import_zod6 = require("zod");
-var USAGE_SCHEMA_VERSION = 1;
-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_zod6.z.strictObject({
-  kind: import_zod6.z.enum(LIMIT_KINDS),
-  /** Seconds to wait before retrying, from the response's `retry-after`. */
-  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_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_zod6.z.array(import_zod6.z.string())
-});
-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_zod6.z.string().optional(),
-  /** `anthropic` for an OAuth session's request to Claude Code's own API, otherwise the provider's name. */
-  provider: import_zod6.z.string(),
-  /** The launch's session id, generated per launch. */
-  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_zod6.z.string().optional(),
-  /** The front-door route that served the request. */
-  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_zod6.z.string(),
-  /** The model the response named. */
-  model: import_zod6.z.string().optional(),
-  status: import_zod6.z.number().int(),
-  /** Milliseconds from the request's arrival to its response head. */
-  latencyMs: import_zod6.z.number().int().nonnegative(),
-  /** Milliseconds from the request's arrival to the end of its response body. */
-  durationMs: import_zod6.z.number().int().nonnegative(),
-  /** Whether the client received the whole body. */
-  outcome: import_zod6.z.enum(["completed", "aborted"]),
-  usage: TokenUsageSchema.optional(),
-  /** The response's quota and rate-limit headers, by name (see `isRateLimitHeader`). */
-  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_zod6.z.string().optional()
-});
-var QuotaWindowSchema = import_zod6.z.strictObject({
-  /** The fraction of the window used, as the upstream reports it (0 to 1). */
-  utilization: import_zod6.z.number().nonnegative().optional(),
-  resetsAt: InstantSchema.optional(),
-  /** The window's own status (`allowed`, `allowed_warning`, `rejected`). */
-  status: import_zod6.z.string().optional()
-});
-var UnifiedRateLimitSchema = import_zod6.z.strictObject({
-  /** The overall status: `allowed`, `allowed_warning` or `rejected`. */
-  status: import_zod6.z.string().optional(),
-  fiveHour: QuotaWindowSchema.optional(),
-  sevenDay: QuotaWindowSchema.optional(),
-  /** The window that currently binds. */
-  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_zod6.z.string().optional()
-});
-var RateLimitStateSchema = import_zod6.z.strictObject({
-  observedAt: InstantSchema,
-  /** Every quota and rate-limit header on that response, by name. */
-  headers: import_zod6.z.record(import_zod6.z.string(), import_zod6.z.string()),
-  unified: UnifiedRateLimitSchema.optional()
-});
-var LimitEventSchema = LimitClassificationSchema.extend({
-  observedAt: InstantSchema,
-  status: import_zod6.z.number().int()
-});
-var ProviderQuotaWindowSchema = import_zod6.z.strictObject({
-  /** What the window measures, in the provider's terms (`tokens`, `tool-calls`). */
-  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_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_zod6.z.string().optional(),
-  /** The fraction of the window used (0 to 1). */
-  utilization: import_zod6.z.number().nonnegative(),
-  resetsAt: InstantSchema.optional(),
-  /** Absolute counts, when the provider reports them for this window. */
-  limit: import_zod6.z.number().nonnegative().optional(),
-  used: import_zod6.z.number().nonnegative().optional(),
-  remaining: import_zod6.z.number().nonnegative().optional()
-});
-var ProviderQuotaSchema = import_zod6.z.strictObject({
-  observedAt: InstantSchema,
-  /** Which usage endpoint produced it (`z.ai`). */
-  source: import_zod6.z.string(),
-  /** The subscription level the endpoint reports, when it does. */
-  level: import_zod6.z.string().optional(),
-  windows: import_zod6.z.array(ProviderQuotaWindowSchema)
-});
-var ProviderUsageStateSchema = import_zod6.z.strictObject({
-  lastRequestAt: InstantSchema,
-  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. */
-  lastLimit: LimitEventSchema.optional(),
-  /** 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_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_zod6.z.strictObject({
-  schemaVersion: VersionSchema,
-  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_zod6.z.record(import_zod6.z.string(), ProviderUsageStateSchema)
-});
-
-// src/usage/account.ts
-var CLAUDE_JSON = ".claude.json";
-var AccountMetadataError = class extends CliError {
-  constructor(file, detail) {
-    super(`${file}: ${detail}, so its account metadata cannot be read.`);
-    this.file = file;
-    this.name = "AccountMetadataError";
-  }
-  file;
-};
-function isObject(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function isIdentityName(name) {
-  return IdentitySchema.shape.name.safeParse(name).success;
-}
-function claudeJsonPath(identitiesDir, identity) {
-  return import_node_path11.default.join(identitiesDir, identity, CLAUDE_JSON);
-}
-function readAccountMetadata(fs12, identitiesDir, identity) {
-  if (!isIdentityName(identity)) {
-    throw new Error(`"${identity}" is not a valid identity name.`);
-  }
-  const file = claudeJsonPath(identitiesDir, identity);
-  const raw = fs12.readFileUtf8(file);
-  if (raw === void 0) {
-    return void 0;
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    throw new AccountMetadataError(file, "not valid JSON");
-  }
-  if (!isObject(parsed)) {
-    throw new AccountMetadataError(file, "not a JSON object");
-  }
-  const oauthAccount = parsed.oauthAccount;
-  if (!isObject(oauthAccount)) {
-    return void 0;
-  }
-  const picked = {};
-  for (const key of Object.keys(AccountMetadataSchema.shape)) {
-    const value = oauthAccount[key];
-    if (value !== null && value !== void 0) {
-      picked[key] = value;
-    }
-  }
-  const account = AccountMetadataSchema.safeParse(picked);
-  if (!account.success) {
-    throw new AccountMetadataError(file, account.error.issues.map((issue) => `${issue.path.join(".")}: ${issue.message}`).join("; "));
-  }
-  return account.data;
-}
-
-// src/usage/read.ts
+var import_node_path13 = __toESM(require("node:path"), 1);
 var SEGMENT_RE = /^(\d{4}-\d{2}-\d{2})\.(\d+)\.jsonl$/;
 var DAY_MS = 864e5;
 function listLogSegments(fs12, logDir) {
@@ -5820,7 +6554,7 @@ function readUsageLog(fs12, logDir, options = {}) {
     if (sinceMs !== void 0 && segment.endsAt <= sinceMs) {
       continue;
     }
-    const contents = fs12.readFileUtf8(import_node_path12.default.join(logDir, segment.name));
+    const contents = fs12.readFileUtf8(import_node_path13.default.join(logDir, segment.name));
     if (contents === void 0) {
       continue;
     }
@@ -5862,7 +6596,7 @@ function snapshotPath(snapshotsDir, identity) {
   if (!isIdentityName(identity)) {
     throw new Error(`"${identity}" is not a valid identity name.`);
   }
-  return import_node_path12.default.join(snapshotsDir, `${identity}.json`);
+  return import_node_path13.default.join(snapshotsDir, `${identity}.json`);
 }
 function readUsageSnapshot(fs12, snapshotsDir, identity) {
   const file = snapshotPath(snapshotsDir, identity);
@@ -5897,13 +6631,13 @@ function listUsageSnapshots(fs12, snapshotsDir) {
 }
 
 // src/usage/preflight.ts
-var MS_PER_SECOND2 = 1e3;
+var MS_PER_SECOND3 = 1e3;
 var SECONDS_PER_MINUTE = 60;
 var MINUTES_PER_HOUR = 60;
 var HOURS_PER_DAY = 24;
 var WARNING_STATUSES = /* @__PURE__ */ new Set(["allowed_warning", "rejected"]);
 function formatAge(ms) {
-  const minutes = Math.floor(ms / (MS_PER_SECOND2 * SECONDS_PER_MINUTE));
+  const minutes = Math.floor(ms / (MS_PER_SECOND3 * SECONDS_PER_MINUTE));
   if (minutes < MINUTES_PER_HOUR) {
     return `${String(Math.max(minutes, 0))}m`;
   }
@@ -5981,13 +6715,13 @@ function planOf(account) {
 }
 
 // src/usage/rateLimit.ts
-var MS_PER_SECOND3 = 1e3;
+var MS_PER_SECOND4 = 1e3;
 function epochSecondsToIso(value) {
   if (value === void 0) {
     return void 0;
   }
   const seconds = Number(value);
-  return Number.isFinite(seconds) && seconds > 0 ? new Date(seconds * MS_PER_SECOND3).toISOString() : void 0;
+  return Number.isFinite(seconds) && seconds > 0 ? new Date(seconds * MS_PER_SECOND4).toISOString() : void 0;
 }
 function nonNegativeNumber(value) {
   if (value === void 0 || value.trim() === "") {
@@ -6044,7 +6778,7 @@ var ErrorObjectSchema = import_zod8.z.looseObject({
 var ANTHROPIC_PROVIDER = "anthropic";
 
 // src/usage/pick.ts
-var MS_PER_SECOND4 = 1e3;
+var MS_PER_SECOND5 = 1e3;
 var MS_PER_HOUR = 36e5;
 var HOURS_PER_DAY2 = 24;
 var FIVE_HOURS = 5;
@@ -6066,7 +6800,7 @@ function limitBlockedUntil(state, nowMs) {
   if (Date.parse(state.lastRequestAt) > Date.parse(limit.observedAt)) {
     return void 0;
   }
-  const until = limit.resetAt === void 0 ? limit.retryAfterSeconds === void 0 ? void 0 : Date.parse(limit.observedAt) + limit.retryAfterSeconds * MS_PER_SECOND4 : Date.parse(limit.resetAt);
+  const until = limit.resetAt === void 0 ? limit.retryAfterSeconds === void 0 ? void 0 : Date.parse(limit.observedAt) + limit.retryAfterSeconds * MS_PER_SECOND5 : Date.parse(limit.resetAt);
   return until !== void 0 && until > nowMs ? until : void 0;
 }
 function windowBlockedUntil(windows) {
@@ -6143,10 +6877,10 @@ function assess(member, nowMs) {
     return { candidate: { ...base, class: "unknown", reasons: ["quota windows reported no utilisation", ...windowReasons, ...planReasons] } };
   }
   const remaining = Math.max(0, 1 - basis.window.utilization);
-  const untilResetMs = basis.window.resetsAtMs === void 0 ? basis.windowMs : Math.max(basis.window.resetsAtMs - nowMs, MS_PER_SECOND4);
+  const untilResetMs = basis.window.resetsAtMs === void 0 ? basis.windowMs : Math.max(basis.window.resetsAtMs - nowMs, MS_PER_SECOND5);
   const score = remaining * plan.capacity / (untilResetMs / MS_PER_HOUR);
   const fiveRemaining = five?.utilization === void 0 ? void 0 : Math.max(0, 1 - five.utilization);
-  const fiveUntil = five?.resetsAtMs === void 0 ? FIVE_HOUR_WINDOW_MS : Math.max(five.resetsAtMs - nowMs, MS_PER_SECOND4);
+  const fiveUntil = five?.resetsAtMs === void 0 ? FIVE_HOUR_WINDOW_MS : Math.max(five.resetsAtMs - nowMs, MS_PER_SECOND5);
   const burn = fiveHourBurn(member.records);
   return {
     candidate: { ...base, class: "scored", score, reasons: [...windowReasons.map((reason, index) => index === windowReasons.length - 1 ? `${reason}${observedAgo}` : reason), ...planReasons] },
@@ -6196,7 +6930,7 @@ function rankPool(input) {
 }
 
 // src/usage/poolPick.ts
-var import_node_path13 = __toESM(require("node:path"), 1);
+var import_node_path14 = __toESM(require("node:path"), 1);
 var import_zod9 = require("zod");
 
 // src/usage/store.ts
@@ -6263,13 +6997,13 @@ function recordStickyPick(fs12, picksFile, directory, identity, nowMs) {
   const current = readPicksFile(fs12, picksFile).file.picks;
   const kept = Object.entries(current).filter(([, entry]) => nowMs - Date.parse(entry.at) <= USAGE_RETENTION_MS);
   const next = { schemaVersion: SCHEMA_VERSION, picks: { ...Object.fromEntries(kept), [directory]: { identity, at: new Date(nowMs).toISOString() } } };
-  fs12.mkdirPrivate(import_node_path13.default.dirname(picksFile));
+  fs12.mkdirPrivate(import_node_path14.default.dirname(picksFile));
   fs12.writeFilePrivate(picksFile, `${JSON.stringify(next, null, 2)}
 `);
 }
 
 // src/launcher/identity.ts
-var import_node_path14 = __toESM(require("node:path"), 1);
+var import_node_path15 = __toESM(require("node:path"), 1);
 function poolNameOf(selector) {
   return selector.startsWith(POOL_SELECTOR_PREFIX) ? selector.slice(POOL_SELECTOR_PREFIX.length) : void 0;
 }
@@ -6318,7 +7052,7 @@ function decideConfigProfile(params) {
   return { source: "none" };
 }
 function loadIdentity(identitiesDir, name, fs12) {
-  return loadConfigFile(import_node_path14.default.join(identitiesDir, name, "identity.json"), IdentitySchema, fs12.readConfigFile);
+  return loadConfigFile(import_node_path15.default.join(identitiesDir, name, "identity.json"), IdentitySchema, fs12.readConfigFile);
 }
 
 // src/launcher/pool.ts
@@ -6533,7 +7267,7 @@ function hashSettings(settings) {
 }
 
 // src/headroom/socket.ts
-var import_node_path15 = __toESM(require("node:path"), 1);
+var import_node_path16 = __toESM(require("node:path"), 1);
 var GROUP_OR_OTHER_BITS = 63;
 var OCTAL_RADIX = 8;
 var MODE_DIGITS = 4;
@@ -6542,7 +7276,7 @@ var HEADROOM_SOCKET_NAME = /^(\d+)\.sock$/;
 var UNIX_SOCKET_PATH_MAX_BYTES = 103;
 var PLATFORMS_WITHOUT_UNIX_SOCKETS = ["win32"];
 function headroomSocketPath(paths, supervisorPid) {
-  return import_node_path15.default.join(paths.headroomSocketDir, `${String(supervisorPid)}${HEADROOM_SOCKET_SUFFIX}`);
+  return import_node_path16.default.join(paths.headroomSocketDir, `${String(supervisorPid)}${HEADROOM_SOCKET_SUFFIX}`);
 }
 function platformRefusal(platform) {
   return PLATFORMS_WITHOUT_UNIX_SOCKETS.includes(platform) ? `headroom routing needs a unix domain socket, which headroom cannot serve on ${platform}; agent-shim never falls back to a TCP port for this hop` : void 0;
@@ -6591,7 +7325,7 @@ function pruneStaleHeadroomSockets(fs12, paths, isRunning) {
     if (pid === void 0 || isRunning(Number.parseInt(pid, 10))) {
       continue;
     }
-    fs12.removeRecursive(import_node_path15.default.join(paths.headroomSocketDir, name));
+    fs12.removeRecursive(import_node_path16.default.join(paths.headroomSocketDir, name));
     removed.push(name);
   }
   return removed;
@@ -6915,14 +7649,14 @@ function evaluateAmbientCredentialGuard(params) {
 // src/paths.ts
 var import_node_fs2 = __toESM(require("node:fs"), 1);
 var import_node_os2 = __toESM(require("node:os"), 1);
-var import_node_path16 = __toESM(require("node:path"), 1);
+var import_node_path17 = __toESM(require("node:path"), 1);
 function resolveAgentShimHome(env = process.env, home = import_node_os2.default.homedir(), isDirectory = isExistingDirectory) {
   const fromEnv = env.AGENT_SHIM_HOME;
   if (fromEnv !== void 0 && fromEnv !== "") {
     return fromEnv;
   }
-  const current = import_node_path16.default.join(home, HOME_DIRNAME);
-  const legacy = import_node_path16.default.join(home, LEGACY_HOME_DIRNAME);
+  const current = import_node_path17.default.join(home, HOME_DIRNAME);
+  const legacy = import_node_path17.default.join(home, LEGACY_HOME_DIRNAME);
   return !isDirectory(current) && isDirectory(legacy) ? legacy : current;
 }
 function isExistingDirectory(candidate) {
@@ -6933,41 +7667,41 @@ function resolveClaudeHome() {
   if (fromEnv !== void 0 && fromEnv !== "") {
     return fromEnv;
   }
-  return import_node_path16.default.join(import_node_os2.default.homedir(), ".claude");
+  return import_node_path17.default.join(import_node_os2.default.homedir(), ".claude");
 }
 function buildLayoutPaths(root) {
   return {
     root,
-    identitiesDir: import_node_path16.default.join(root, "identities"),
-    configProfilesDir: import_node_path16.default.join(root, "config-profiles"),
-    providersDir: import_node_path16.default.join(root, "providers"),
-    directoryRulesFile: import_node_path16.default.join(root, "directory-rules.json"),
-    activeIdentityFile: import_node_path16.default.join(root, "active-identity"),
-    globalConfigFile: import_node_path16.default.join(root, "config.json"),
-    categoriesLocalFile: import_node_path16.default.join(root, "categories.local.json"),
-    claudeShimFile: import_node_path16.default.join(root, "claude-shim.json"),
-    headroomDir: import_node_path16.default.join(root, "headroom"),
-    headroomStateFile: import_node_path16.default.join(root, "headroom", `state.v${String(HEADROOM_STATE_SCHEMA_VERSION)}.json`),
-    headroomSocketDir: import_node_path16.default.join(root, "headroom", "run"),
-    headroomLockFile: import_node_path16.default.join(root, "headroom", "start.lock"),
-    headroomSessionsDir: import_node_path16.default.join(root, "headroom", "sessions"),
-    logsDir: import_node_path16.default.join(root, "logs"),
-    headroomLogPath: import_node_path16.default.join(root, "logs", "headroom.log"),
-    frontdoorDir: import_node_path16.default.join(root, "frontdoor"),
-    frontdoorCaDir: import_node_path16.default.join(root, "frontdoor", "ca"),
-    frontdoorCaCertFile: import_node_path16.default.join(root, "frontdoor", "ca", "ca.pem"),
-    frontdoorCaKeyFile: import_node_path16.default.join(root, "frontdoor", "ca", "ca.key"),
-    frontdoorCaBundlesDir: import_node_path16.default.join(root, "frontdoor", "ca", "bundles"),
-    frontdoorStateFile: import_node_path16.default.join(root, "frontdoor", "state.json"),
-    frontdoorLockFile: import_node_path16.default.join(root, "frontdoor", "start.lock"),
-    frontdoorControlTokenFile: import_node_path16.default.join(root, "frontdoor", "control-token"),
-    frontdoorSessionsDir: import_node_path16.default.join(root, "frontdoor", "sessions"),
-    frontdoorRcCredentialsDir: import_node_path16.default.join(root, "frontdoor", "rc-credentials"),
-    frontdoorLogPath: import_node_path16.default.join(root, "logs", "frontdoor.log"),
-    usageDir: import_node_path16.default.join(root, "usage"),
-    usageLogDir: import_node_path16.default.join(root, "usage", "log"),
-    usageSnapshotsDir: import_node_path16.default.join(root, "usage", "snapshots"),
-    usagePicksFile: import_node_path16.default.join(root, "usage", "picks.json")
+    identitiesDir: import_node_path17.default.join(root, "identities"),
+    configProfilesDir: import_node_path17.default.join(root, "config-profiles"),
+    providersDir: import_node_path17.default.join(root, "providers"),
+    directoryRulesFile: import_node_path17.default.join(root, "directory-rules.json"),
+    activeIdentityFile: import_node_path17.default.join(root, "active-identity"),
+    globalConfigFile: import_node_path17.default.join(root, "config.json"),
+    categoriesLocalFile: import_node_path17.default.join(root, "categories.local.json"),
+    claudeShimFile: import_node_path17.default.join(root, "claude-shim.json"),
+    headroomDir: import_node_path17.default.join(root, "headroom"),
+    headroomStateFile: import_node_path17.default.join(root, "headroom", `state.v${String(HEADROOM_STATE_SCHEMA_VERSION)}.json`),
+    headroomSocketDir: import_node_path17.default.join(root, "headroom", "run"),
+    headroomLockFile: import_node_path17.default.join(root, "headroom", "start.lock"),
+    headroomSessionsDir: import_node_path17.default.join(root, "headroom", "sessions"),
+    logsDir: import_node_path17.default.join(root, "logs"),
+    headroomLogPath: import_node_path17.default.join(root, "logs", "headroom.log"),
+    frontdoorDir: import_node_path17.default.join(root, "frontdoor"),
+    frontdoorCaDir: import_node_path17.default.join(root, "frontdoor", "ca"),
+    frontdoorCaCertFile: import_node_path17.default.join(root, "frontdoor", "ca", "ca.pem"),
+    frontdoorCaKeyFile: import_node_path17.default.join(root, "frontdoor", "ca", "ca.key"),
+    frontdoorCaBundlesDir: import_node_path17.default.join(root, "frontdoor", "ca", "bundles"),
+    frontdoorStateFile: import_node_path17.default.join(root, "frontdoor", "state.json"),
+    frontdoorLockFile: import_node_path17.default.join(root, "frontdoor", "start.lock"),
+    frontdoorControlTokenFile: import_node_path17.default.join(root, "frontdoor", "control-token"),
+    frontdoorSessionsDir: import_node_path17.default.join(root, "frontdoor", "sessions"),
+    frontdoorRcCredentialsDir: import_node_path17.default.join(root, "frontdoor", "rc-credentials"),
+    frontdoorLogPath: import_node_path17.default.join(root, "logs", "frontdoor.log"),
+    usageDir: import_node_path17.default.join(root, "usage"),
+    usageLogDir: import_node_path17.default.join(root, "usage", "log"),
+    usageSnapshotsDir: import_node_path17.default.join(root, "usage", "snapshots"),
+    usagePicksFile: import_node_path17.default.join(root, "usage", "picks.json")
   };
 }
 function resolveLayoutPaths() {
@@ -6976,11 +7710,11 @@ function resolveLayoutPaths() {
 
 // src/identityStore.ts
 var import_node_fs4 = __toESM(require("node:fs"), 1);
-var import_node_path18 = __toESM(require("node:path"), 1);
+var import_node_path19 = __toESM(require("node:path"), 1);
 
 // src/configProfilesStore.ts
 var import_node_fs3 = __toESM(require("node:fs"), 1);
-var import_node_path17 = __toESM(require("node:path"), 1);
+var import_node_path18 = __toESM(require("node:path"), 1);
 var ProfileNotFoundError = class extends CliError {
   constructor(profileName) {
     super(`No configuration profile named "${profileName}". Run \`agent-shim profile add ${profileName}\` first.`);
@@ -7006,7 +7740,7 @@ var InvalidCategoryNameError = class extends CliError {
   categoryName;
 };
 function profileJsonPath(paths, name) {
-  return import_node_path17.default.join(paths.configProfilesDir, `${name}.json`);
+  return import_node_path18.default.join(paths.configProfilesDir, `${name}.json`);
 }
 function profileExists(paths, name) {
   return import_node_fs3.default.existsSync(profileJsonPath(paths, name));
@@ -7194,7 +7928,7 @@ var InvalidIdentityNameError = class extends CliError {
   attemptedName;
 };
 function identityJsonPath(paths, name) {
-  return import_node_path18.default.join(paths.identitiesDir, name, "identity.json");
+  return import_node_path19.default.join(paths.identitiesDir, name, "identity.json");
 }
 function identityExists(paths, name) {
   return import_node_fs4.default.existsSync(identityJsonPath(paths, name));
@@ -7295,7 +8029,7 @@ function setIdentityCredential(paths, identityName, change) {
   });
 }
 function belongsToIdentity(entry, name) {
-  return entry === name || entry === import_node_path18.default.basename(identityLockPath("", name)) || entry.startsWith(`.${name}.scratch.`) || entry.startsWith(`.${name}.previous.`);
+  return entry === name || entry === import_node_path19.default.basename(identityLockPath("", name)) || entry.startsWith(`.${name}.scratch.`) || entry.startsWith(`.${name}.previous.`);
 }
 function removeIdentity(paths, name) {
   if (!identityExists(paths, name)) {
@@ -7303,7 +8037,7 @@ function removeIdentity(paths, name) {
   }
   for (const entry of import_node_fs4.default.readdirSync(paths.identitiesDir)) {
     if (belongsToIdentity(entry, name)) {
-      import_node_fs4.default.rmSync(import_node_path18.default.join(paths.identitiesDir, entry), { recursive: true, force: true });
+      import_node_fs4.default.rmSync(import_node_path19.default.join(paths.identitiesDir, entry), { recursive: true, force: true });
     }
   }
   if (readActiveIdentity(paths) === name) {
@@ -7313,7 +8047,7 @@ function removeIdentity(paths, name) {
 
 // src/providersStore.ts
 var import_node_fs5 = __toESM(require("node:fs"), 1);
-var import_node_path19 = __toESM(require("node:path"), 1);
+var import_node_path20 = __toESM(require("node:path"), 1);
 
 // src/credentialCache.ts
 var import_zod12 = require("zod");
@@ -7578,7 +8312,7 @@ var InvalidProviderNameError = class extends CliError {
 };
 var PROVIDER_NAME_RE = /^[A-Za-z0-9][A-Za-z0-9._@-]*$/;
 function providerJsonPath(paths, name) {
-  return import_node_path19.default.join(paths.providersDir, `${name}.json`);
+  return import_node_path20.default.join(paths.providersDir, `${name}.json`);
 }
 function providerExists(paths, name) {
   return import_node_fs5.default.existsSync(providerJsonPath(paths, name));
@@ -7586,14 +8320,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 isRecord5(value) {
+function isRecord7(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function legacyProviderConversion(raw) {
-  if (!isRecord5(raw) || "credential" in raw) {
+  if (!isRecord7(raw) || "credential" in raw) {
     return void 0;
   }
-  const env = isRecord5(raw.env) ? raw.env : void 0;
+  const env = isRecord7(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) {
@@ -7654,7 +8388,7 @@ function readProvider(paths, name) {
   return parseProviderFile(filePath, raw);
 }
 function loadProvider(providersDir, name, port) {
-  const filePath = import_node_path19.default.join(providersDir, `${name}.json`);
+  const filePath = import_node_path20.default.join(providersDir, `${name}.json`);
   const raw = port.readConfigFile(filePath);
   return raw === void 0 ? void 0 : parseProviderFile(filePath, raw);
 }
@@ -7909,21 +8643,21 @@ function removeDirectoryRule(paths, rulePath) {
 var import_node_os4 = __toESM(require("node:os"), 1);
 
 // src/launcher/cascade.ts
-var import_node_path21 = __toESM(require("node:path"), 1);
+var import_node_path22 = __toESM(require("node:path"), 1);
 
 // src/pathNorm.ts
-var import_node_path20 = __toESM(require("node:path"), 1);
+var import_node_path21 = __toESM(require("node:path"), 1);
 function expandTilde(value, home) {
   if (value === "~") {
     return home;
   }
   if (value.startsWith("~/")) {
-    return import_node_path20.default.join(home, value.slice(2));
+    return import_node_path21.default.join(home, value.slice(2));
   }
   return value;
 }
 function normaliseRulePath(rulePath, home) {
-  return import_node_path20.default.resolve(expandTilde(rulePath, home));
+  return import_node_path21.default.resolve(expandTilde(rulePath, home));
 }
 
 // src/launcher/cascade.ts
@@ -7933,7 +8667,7 @@ function loadCascadeInput(params) {
   const globalConfig = loadConfigFile(params.paths.globalConfigFile, GlobalConfigSchema, params.read);
   const directoryRules = loadConfigFile(params.paths.directoryRulesFile, DirectoryRulesSchema, params.read);
   const loadProfile = (name) => {
-    const filepath = import_node_path21.default.join(params.paths.configProfilesDir, `${name}.json`);
+    const filepath = import_node_path22.default.join(params.paths.configProfilesDir, `${name}.json`);
     const loaded = loadConfigFile(filepath, ConfigProfileSchema, params.read);
     if (loaded === void 0) {
       return void 0;
@@ -7948,8 +8682,8 @@ function loadCascadeInput(params) {
   });
   const levels = [];
   for (const dir of dirs) {
-    const portable = loadConfigFile(import_node_path21.default.join(dir, PORTABLE_CONFIG_FILENAME), PortableConfigSchema, params.read) ?? loadConfigFile(import_node_path21.default.join(dir, LEGACY_PORTABLE_CONFIG_FILENAME), PortableConfigSchema, params.read);
-    const portableLocal = loadConfigFile(import_node_path21.default.join(dir, PORTABLE_LOCAL_CONFIG_FILENAME), PortableConfigSchema, params.read) ?? loadConfigFile(import_node_path21.default.join(dir, LEGACY_PORTABLE_LOCAL_CONFIG_FILENAME), PortableConfigSchema, params.read);
+    const portable = loadConfigFile(import_node_path22.default.join(dir, PORTABLE_CONFIG_FILENAME), PortableConfigSchema, params.read) ?? loadConfigFile(import_node_path22.default.join(dir, LEGACY_PORTABLE_CONFIG_FILENAME), PortableConfigSchema, params.read);
+    const portableLocal = loadConfigFile(import_node_path22.default.join(dir, PORTABLE_LOCAL_CONFIG_FILENAME), PortableConfigSchema, params.read) ?? loadConfigFile(import_node_path22.default.join(dir, LEGACY_PORTABLE_LOCAL_CONFIG_FILENAME), PortableConfigSchema, params.read);
     const rules = (directoryRules?.config.rules ?? []).map((rule, index) => ({ rule, index })).filter(({ rule }) => normaliseRulePath(rule.path, params.home) === dir).map(({ rule, index }) => {
       const entryOrder = directoryRules?.ruleEntryOrders[index];
       return {
@@ -8000,7 +8734,7 @@ function readDirectorySelections(loaded) {
 // src/realCredentialCache.ts
 var import_node_child_process = require("node:child_process");
 var import_node_fs6 = __toESM(require("node:fs"), 1);
-var import_node_path22 = __toESM(require("node:path"), 1);
+var import_node_path23 = __toESM(require("node:path"), 1);
 var KEYCHAIN_CACHE_SERVICE = "agent-shim-credential-cache";
 var CACHE_DIR_MODE = 448;
 var CACHE_FILE_MODE = 384;
@@ -8027,8 +8761,8 @@ function security(args, stdin) {
   return { status: result.status, stdout: result.stdout };
 }
 function createRealCredentialCache(root) {
-  const dir = import_node_path22.default.join(root, "credential-cache");
-  const filePath = (owner) => import_node_path22.default.join(dir, cacheFileNameFor(owner));
+  const dir = import_node_path23.default.join(root, "credential-cache");
+  const filePath = (owner) => import_node_path23.default.join(dir, cacheFileNameFor(owner));
   return {
     read(store, owner) {
       if (store === "file") {
@@ -8080,7 +8814,7 @@ var import_node_child_process2 = require("node:child_process");
 var import_node_crypto9 = require("node:crypto");
 var import_node_fs7 = __toESM(require("node:fs"), 1);
 var import_node_os3 = __toESM(require("node:os"), 1);
-var import_node_path23 = __toESM(require("node:path"), 1);
+var import_node_path24 = __toESM(require("node:path"), 1);
 var import_node_sea = require("node:sea");
 function isEnoent3(error) {
   return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
@@ -8239,7 +8973,7 @@ var realRunPort = {
   }
 };
 function expandHome2(filePath) {
-  return filePath.startsWith("~/") ? import_node_path23.default.join(import_node_os3.default.homedir(), filePath.slice(1)) : filePath;
+  return filePath.startsWith("~/") ? import_node_path24.default.join(import_node_os3.default.homedir(), filePath.slice(1)) : filePath;
 }
 var MACOS_GUI_SESSION_MANAGER = "Aqua";
 function hasDesktopSession() {
@@ -8312,7 +9046,7 @@ function spawnDaemonThrough(executable) {
   return (paths, subcommand, logPath) => spawnDetachedDaemon({ command: executable, args: [subcommand] }, paths, subcommand, logPath);
 }
 function spawnDetachedDaemon(invocation, paths, subcommand, logPath) {
-  import_node_fs7.default.mkdirSync(import_node_path23.default.dirname(logPath), { recursive: true });
+  import_node_fs7.default.mkdirSync(import_node_path24.default.dirname(logPath), { recursive: true });
   const logFd = import_node_fs7.default.openSync(logPath, "a");
   try {
     const child = (0, import_node_child_process2.spawn)(invocation.command, invocation.args, detachedDaemonSpawnOptions(logFd, { ...process.env, AGENT_SHIM_HOME: paths.root }));
@@ -8394,7 +9128,7 @@ function listVersionsDir(dir) {
     throw error;
   }
   return entries.filter((entry) => entry.isFile()).map((entry) => {
-    const fullPath = import_node_path23.default.join(dir, entry.name);
+    const fullPath = import_node_path24.default.join(dir, entry.name);
     const stat = import_node_fs7.default.statSync(fullPath);
     return {
       name: entry.name,
@@ -8409,7 +9143,7 @@ function windowsPathExtensions(pathext) {
   return (pathext ?? WINDOWS_DEFAULT_PATHEXT).split(";").map((ext) => ext.trim()).filter((ext) => ext.length > 0);
 }
 function resolveExecutableCandidate(dir, name, env) {
-  const candidate = import_node_path23.default.join(dir, name);
+  const candidate = import_node_path24.default.join(dir, name);
   if (env.platform === "win32") {
     const extensions = windowsPathExtensions(env.pathext);
     const alreadyHasRecognisedExtension = extensions.some((ext) => candidate.toLowerCase().endsWith(ext.toLowerCase()));
@@ -8458,13 +9192,13 @@ function resolveOwnExecutablePath(env) {
   if (env.argv1 !== void 0 && !env.argv1.includes("/") && !env.argv1.includes("\\")) {
     return searchPathForExecutable(env.pathDirs, env.argv1, env.findExecutableInDir) ?? env.execPath;
   }
-  const candidate = env.argv1 === void 0 ? env.execPath : import_node_path23.default.resolve(env.cwd, env.argv1);
-  const candidateDir = import_node_path23.default.dirname(candidate);
-  const candidateDirOnPath = env.pathDirs.some((dir) => import_node_path23.default.resolve(dir) === candidateDir);
+  const candidate = env.argv1 === void 0 ? env.execPath : import_node_path24.default.resolve(env.cwd, env.argv1);
+  const candidateDir = import_node_path24.default.dirname(candidate);
+  const candidateDirOnPath = env.pathDirs.some((dir) => import_node_path24.default.resolve(dir) === candidateDir);
   if (candidateDirOnPath) {
     return candidate;
   }
-  const viaPath = searchPathForExecutable(env.pathDirs, import_node_path23.default.basename(candidate), env.findExecutableInDir);
+  const viaPath = searchPathForExecutable(env.pathDirs, import_node_path24.default.basename(candidate), env.findExecutableInDir);
   return viaPath ?? candidate;
 }
 function realOwnExecutablePath() {
@@ -8472,7 +9206,7 @@ function realOwnExecutablePath() {
     argv1: process.argv[1],
     execPath: process.execPath,
     cwd: process.cwd(),
-    pathDirs: (process.env.PATH ?? "").split(import_node_path23.default.delimiter).filter((dir) => dir !== ""),
+    pathDirs: (process.env.PATH ?? "").split(import_node_path24.default.delimiter).filter((dir) => dir !== ""),
     findExecutableInDir
   });
 }
@@ -8485,7 +9219,7 @@ function realContentSourcePath() {
 function realResolveClaudeBinary(isOwnBinary) {
   return (request4) => discoverClaudeBinary({
     listVersionsDir,
-    pathDirs: (process.env.PATH ?? "").split(import_node_path23.default.delimiter).filter((dir) => dir !== ""),
+    pathDirs: (process.env.PATH ?? "").split(import_node_path24.default.delimiter).filter((dir) => dir !== ""),
     findExecutableInDir,
     isOwnBinary,
     ...request4?.version === void 0 ? {} : { version: request4.version }
@@ -8496,7 +9230,7 @@ function realInstalledClaudeVersions() {
 }
 
 // src/checkReport.ts
-var import_node_path24 = __toESM(require("node:path"), 1);
+var import_node_path25 = __toESM(require("node:path"), 1);
 var import_zod13 = require("zod");
 
 // src/cli/bool.ts
@@ -8928,10 +9662,10 @@ function collectCheckReport(params) {
   }).input;
   const providerName = cascadeProviderName(cascade);
   const provider = providerName === void 0 ? void 0 : loadCheckProvider(paths, providerName);
-  const farmRoot = identityDecision.name === void 0 ? void 0 : import_node_path24.default.join(paths.identitiesDir, identityDecision.name);
+  const farmRoot = identityDecision.name === void 0 ? void 0 : import_node_path25.default.join(paths.identitiesDir, identityDecision.name);
   const settingsFiles = {
-    "settings.json": realFsPort.readFileUtf8(import_node_path24.default.join(claudeHome, "settings.json")),
-    "settings.local.json": realFsPort.readFileUtf8(import_node_path24.default.join(claudeHome, "settings.local.json"))
+    "settings.json": realFsPort.readFileUtf8(import_node_path25.default.join(claudeHome, "settings.json")),
+    "settings.local.json": realFsPort.readFileUtf8(import_node_path25.default.join(claudeHome, "settings.local.json"))
   };
   const report = runCheck({
     cwd,
@@ -8963,7 +9697,7 @@ function collectCheckReport(params) {
 
 // src/claudeShim.ts
 var import_node_fs8 = __toESM(require("node:fs"), 1);
-var import_node_path25 = __toESM(require("node:path"), 1);
+var import_node_path26 = __toESM(require("node:path"), 1);
 var import_zod14 = require("zod");
 var ClaudeShimStateSchema = import_zod14.z.strictObject({
   targetPath: import_zod14.z.string().min(1),
@@ -8975,10 +9709,10 @@ function commandFilename(ownExecutablePath, commandName) {
 }
 function resolveOwnBinaryCheck(paths, contentSourcePath) {
   const state = readJson(paths.claudeShimFile, ClaudeShimStateSchema);
-  const recordedTarget = state === void 0 ? void 0 : import_node_path25.default.resolve(state.targetPath);
+  const recordedTarget = state === void 0 ? void 0 : import_node_path26.default.resolve(state.targetPath);
   let ownStat;
   return (candidate) => {
-    if (recordedTarget !== void 0 && import_node_path25.default.resolve(candidate) === recordedTarget) {
+    if (recordedTarget !== void 0 && import_node_path26.default.resolve(candidate) === recordedTarget) {
       return true;
     }
     ownStat ??= statOrUndefined(contentSourcePath);
@@ -9002,20 +9736,20 @@ function statOrUndefined(target) {
 }
 var nodeLinkFs = { link: import_node_fs8.default.linkSync, copyFile: import_node_fs8.default.copyFileSync, chmod: import_node_fs8.default.chmodSync };
 function findPathShadow(params) {
-  const resolvedTargetDir = import_node_path25.default.resolve(params.targetDir);
+  const resolvedTargetDir = import_node_path26.default.resolve(params.targetDir);
   for (const dir of params.pathDirs) {
     const found = params.findExecutableInDir(dir, params.targetFilename);
     if (found === void 0) {
       continue;
     }
-    return import_node_path25.default.resolve(dir) === resolvedTargetDir ? { status: "ok" } : { status: "shadowed", by: found };
+    return import_node_path26.default.resolve(dir) === resolvedTargetDir ? { status: "ok" } : { status: "shadowed", by: found };
   }
-  return params.pathDirs.some((dir) => import_node_path25.default.resolve(dir) === resolvedTargetDir) ? { status: "ok" } : { status: "not-on-path" };
+  return params.pathDirs.some((dir) => import_node_path26.default.resolve(dir) === resolvedTargetDir) ? { status: "ok" } : { status: "not-on-path" };
 }
 
 // src/doctorReport.ts
 var import_node_fs9 = __toESM(require("node:fs"), 1);
-var import_node_path26 = __toESM(require("node:path"), 1);
+var import_node_path27 = __toESM(require("node:path"), 1);
 function refinePathShadow(status, ownExecutablePath, realpath) {
   if (status.status !== "shadowed") {
     return status;
@@ -9039,7 +9773,7 @@ function validateJson(schema, input) {
   return { ok: true, data: result.data };
 }
 function pushPathResolution(push, resolution) {
-  const ownDir = import_node_path26.default.dirname(resolution.ownExecutablePath);
+  const ownDir = import_node_path27.default.dirname(resolution.ownExecutablePath);
   switch (resolution.agentShim.status) {
     case "ok":
       push("path-resolution", "pass", `\`agent-shim\` on PATH resolves to this running executable, ${resolution.ownExecutablePath}.`, "agent-shim");
@@ -9118,14 +9852,14 @@ function pushProvider(push, entry, cacheEnv) {
 }
 function pushLegacyName(push, params) {
   const legacyVariables = Object.keys(params.env).filter((name) => name.startsWith(LEGACY_ENV_PREFIX) && params.env[name] !== void 0).sort();
-  if (legacyVariables.length === 0 && import_node_path26.default.basename(params.rootPath) !== LEGACY_HOME_DIRNAME) {
+  if (legacyVariables.length === 0 && import_node_path27.default.basename(params.rootPath) !== LEGACY_HOME_DIRNAME) {
     push("legacy-name", "pass", "Nothing here still uses the former `claude-use` name.");
     return;
   }
   for (const name of legacyVariables) {
     push("legacy-name", "warn", `${name} is the former name of ${name.replace(LEGACY_ENV_PREFIX, ENV_PREFIX)}. Rename it; the old name still works but is only a fallback.`, name);
   }
-  if (import_node_path26.default.basename(params.rootPath) === LEGACY_HOME_DIRNAME) {
+  if (import_node_path27.default.basename(params.rootPath) === LEGACY_HOME_DIRNAME) {
     push(
       "legacy-name",
       "warn",
@@ -9444,18 +10178,18 @@ function collectDoctorReport(params) {
   const { paths } = params;
   const identityNames = import_node_fs9.default.existsSync(paths.identitiesDir) ? import_node_fs9.default.readdirSync(paths.identitiesDir, { withFileTypes: true }).filter((entry) => entry.isDirectory() && isIdentityDirectoryName(entry.name)).map((entry) => entry.name).sort() : [];
   const identities = identityNames.map((name) => {
-    const farmRoot = import_node_path26.default.join(paths.identitiesDir, name);
-    const identityPath = import_node_path26.default.join(farmRoot, "identity.json");
+    const farmRoot = import_node_path27.default.join(paths.identitiesDir, name);
+    const identityPath = import_node_path27.default.join(farmRoot, "identity.json");
     return { name, path: identityPath, raw: realFsPort.readFileUtf8(identityPath), farmRoot };
   });
   const profileNames = import_node_fs9.default.existsSync(paths.configProfilesDir) ? import_node_fs9.default.readdirSync(paths.configProfilesDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.slice(0, -".json".length)).sort() : [];
   const configProfiles = profileNames.map((name) => {
-    const profilePath = import_node_path26.default.join(paths.configProfilesDir, `${name}.json`);
+    const profilePath = import_node_path27.default.join(paths.configProfilesDir, `${name}.json`);
     return { name, path: profilePath, raw: realFsPort.readFileUtf8(profilePath) };
   });
   const providerNames = import_node_fs9.default.existsSync(paths.providersDir) ? import_node_fs9.default.readdirSync(paths.providersDir, { withFileTypes: true }).filter((entry) => entry.isFile() && entry.name.endsWith(".json")).map((entry) => entry.name.slice(0, -".json".length)).sort() : [];
   const providers = providerNames.map((name) => {
-    const providerPath = import_node_path26.default.join(paths.providersDir, `${name}.json`);
+    const providerPath = import_node_path27.default.join(paths.providersDir, `${name}.json`);
     return { name, path: providerPath, raw: realFsPort.readFileUtf8(providerPath) };
   });
   const ownExecutablePath = realOwnExecutablePath();
@@ -9467,12 +10201,12 @@ function collectDoctorReport(params) {
     binaryDiscovery = { ok: false, message: error instanceof Error ? error.message : String(error) };
   }
   const shimState = readJson(paths.claudeShimFile, ClaudeShimStateSchema);
-  const pathDirs = (params.env.PATH ?? "").split(import_node_path26.default.delimiter).filter((dir) => dir !== "");
+  const pathDirs = (params.env.PATH ?? "").split(import_node_path27.default.delimiter).filter((dir) => dir !== "");
   const claudeShimShadow = shimState === void 0 ? void 0 : refinePathShadow(
     findPathShadow({
       pathDirs,
-      targetDir: import_node_path26.default.dirname(shimState.targetPath),
-      targetFilename: import_node_path26.default.basename(shimState.targetPath),
+      targetDir: import_node_path27.default.dirname(shimState.targetPath),
+      targetFilename: import_node_path27.default.basename(shimState.targetPath),
       findExecutableInDir
     }),
     shimState.targetPath,
@@ -9497,7 +10231,7 @@ function collectDoctorReport(params) {
       agentShim: refinePathShadow(
         findPathShadow({
           pathDirs,
-          targetDir: import_node_path26.default.dirname(ownExecutablePath),
+          targetDir: import_node_path27.default.dirname(ownExecutablePath),
           targetFilename: commandFilename(ownExecutablePath, "agent-shim"),
           findExecutableInDir
         }),
@@ -9518,7 +10252,7 @@ function collectDoctorReport(params) {
 
 // src/launcher.ts
 var import_node_crypto10 = require("node:crypto");
-var import_node_path28 = __toESM(require("node:path"), 1);
+var import_node_path29 = __toESM(require("node:path"), 1);
 
 // src/launcher/argv.ts
 var ConflictingIdentityError = class extends UsageError {
@@ -9783,7 +10517,7 @@ function buildCliOverride(params) {
 }
 
 // src/launcher/flags.ts
-var import_node_path27 = __toESM(require("node:path"), 1);
+var import_node_path28 = __toESM(require("node:path"), 1);
 
 // src/headroom/headers.ts
 function mergeAnthropicCustomHeaders(existing, additions) {
@@ -9853,7 +10587,7 @@ function buildEnv(params) {
   const parentCustomHeaders = params.baseEnv.ANTHROPIC_CUSTOM_HEADERS;
   let providerCustomHeaders;
   if (!params.configDirEscapeHatch && params.resolvedIdentityName !== void 0) {
-    env.CLAUDE_CONFIG_DIR = import_node_path27.default.join(params.identitiesDir, params.resolvedIdentityName);
+    env.CLAUDE_CONFIG_DIR = import_node_path28.default.join(params.identitiesDir, params.resolvedIdentityName);
   }
   if (params.provider !== void 0) {
     const providerEnv = params.provider.definition.env ?? {};
@@ -9910,6 +10644,29 @@ function splitExtraFlags(value) {
   return trimmed.split(/\s+/);
 }
 
+// src/launcher/spawn.ts
+var import_node_os5 = __toESM(require("node:os"), 1);
+var SIGNAL_EXIT_CODE_OFFSET = 128;
+function exitCodeFor(result) {
+  if (result.status !== null) {
+    return result.status;
+  }
+  if (result.signal !== null) {
+    return SIGNAL_EXIT_CODE_OFFSET + import_node_os5.default.constants.signals[result.signal];
+  }
+  return 1;
+}
+function spawnClaude(params) {
+  const result = params.spawn.spawnSync(params.bin, params.args, { stdio: "inherit", env: params.env });
+  if (result.error !== void 0) {
+    throw result.error;
+  }
+  if (params.beforeExit !== void 0) {
+    params.beforeExit();
+  }
+  return params.proc.exit(exitCodeFor(result));
+}
+
 // src/launcher.ts
 function resolveIdentityCredential(identity, credential, env, port) {
   if (port === void 0) {
@@ -10014,7 +10771,7 @@ function prepareLaunch(params) {
     identityDefaultConfigProfile: loadedIdentity?.config.defaultConfigProfile,
     globalDefaultConfigProfile: params.globalDefaultConfigProfile
   });
-  if (configProfileDecision.name !== void 0 && params.allowMissingConfigProfile !== true && fs12.readConfigFile(import_node_path28.default.join(paths.configProfilesDir, `${configProfileDecision.name}.json`)) === void 0) {
+  if (configProfileDecision.name !== void 0 && params.allowMissingConfigProfile !== true && fs12.readConfigFile(import_node_path29.default.join(paths.configProfilesDir, `${configProfileDecision.name}.json`)) === void 0) {
     log.error(
       `agent-shim: no configuration profile named "${configProfileDecision.name}" (selected via ${configProfileDecision.source}). Run \`agent-shim profile add ${configProfileDecision.name}\` first.`
     );
@@ -10186,9 +10943,17 @@ function prepareLaunch(params) {
   };
   return { bin: discovered.path, args: finalArgv, env: finalEnv, release };
 }
+function runLauncher(params) {
+  const plan = prepareLaunch(params);
+  try {
+    spawnClaude({ bin: plan.bin, args: plan.args, env: plan.env, spawn: params.spawn, proc: params.proc, beforeExit: plan.release });
+  } finally {
+    plan.release();
+  }
+}
 
 // src/launchWiring.ts
-var import_node_os5 = __toESM(require("node:os"), 1);
+var import_node_os6 = __toESM(require("node:os"), 1);
 var import_node_crypto12 = require("node:crypto");
 
 // src/frontdoor/realFrontDoorPort.ts
@@ -10260,11 +11025,11 @@ function probeFrontDoorSync(port, caPem) {
 
 // src/frontdoor/trust.ts
 var import_node_crypto11 = require("node:crypto");
-var import_node_path29 = __toESM(require("node:path"), 1);
+var import_node_path30 = __toESM(require("node:path"), 1);
 var BUNDLE_NAME_HEX_DIGITS = 16;
 function resolveTrustBundle(params) {
   const { caCertFile, bundlesDir, variable, inherited, fs: fs12 } = params;
-  if (inherited === void 0 || inherited === "" || import_node_path29.default.resolve(inherited) === import_node_path29.default.resolve(caCertFile)) {
+  if (inherited === void 0 || inherited === "" || import_node_path30.default.resolve(inherited) === import_node_path30.default.resolve(caCertFile)) {
     return { path: caCertFile };
   }
   const caPem = fs12.readFileUtf8(caCertFile);
@@ -10282,7 +11047,7 @@ function resolveTrustBundle(params) {
   }
   const combined = `${inheritedPem.trimEnd()}
 ${caPem}`;
-  const bundle = import_node_path29.default.join(bundlesDir, `${(0, import_node_crypto11.createHash)("sha256").update(combined).digest("hex").slice(0, BUNDLE_NAME_HEX_DIGITS)}.pem`);
+  const bundle = import_node_path30.default.join(bundlesDir, `${(0, import_node_crypto11.createHash)("sha256").update(combined).digest("hex").slice(0, BUNDLE_NAME_HEX_DIGITS)}.pem`);
   if (!fs12.exists(bundle)) {
     fs12.mkdirp(bundlesDir);
     fs12.writeFileAtomic(bundle, combined);
@@ -10337,7 +11102,7 @@ function realFrontDoorPort(paths, spawnDaemon) {
 
 // src/launchWiring.ts
 function buildFarmRuntime(paths, cwd) {
-  const home = import_node_os5.default.homedir();
+  const home = import_node_os6.default.homedir();
   const read = cosmiconfigReader();
   const classification = loadClassification(paths);
   const loaded = loadCascadeInput({ paths, home, cwd, read });
@@ -10476,6 +11241,13 @@ function prepareClaudeLaunch(options) {
   RC_PENDING_DEADLINE_MS,
   RC_PERMISSION_MODES,
   RC_REQUEST_PARSE_CAP_BYTES,
+  RC_SELF_HOST_ENV,
+  RC_SELF_HOST_KEEPALIVE_MS,
+  RC_SELF_HOST_RECORD_DIR,
+  RC_SELF_HOST_RECORD_FILE,
+  RC_SELF_HOST_RETENTION_MS,
+  RC_SELF_HOST_SCOPE_LIST,
+  RC_SELF_HOST_WORKER_JWT_TTL_SECONDS,
   RC_SESSIONS_PATH_PREFIX,
   RC_STREAM_BACKOFF_MS,
   ROUTED_PATH_PREFIX,
@@ -10512,6 +11284,7 @@ function prepareClaudeLaunch(options) {
   createRcControlHandler,
   createRcCredentialStore,
   createRcEventFanout,
+  createRcSelfHostSurface,
   createRcSessionTracker,
   createRcStreamHub,
   createSseParser,
@@ -10536,6 +11309,8 @@ function prepareClaudeLaunch(options) {
   isIdentityDirectoryName,
   isInterceptedHost,
   isRcPermissionMode,
+  lateRcEventDial,
+  lateRcStreamDial,
   listDirectoryRules,
   listIdentities,
   listProfiles,
@@ -10543,6 +11318,7 @@ function prepareClaudeLaunch(options) {
   listUsageSnapshots,
   matchBranch,
   mintLeaf,
+  mintRcSelfHostCredential,
   observingRoutedRoute,
   parseConnectTarget,
   parseRcStreamEnvelope,
@@ -10554,6 +11330,7 @@ function prepareClaudeLaunch(options) {
   rankPool,
   rcEventWriteResultFromAnswer,
   rcObserverAsPassthrough,
+  rcSelfHostFromEnv,
   readActiveIdentity,
   readDirectoryRules,
   readFarmManifest,
@@ -10562,6 +11339,7 @@ function prepareClaudeLaunch(options) {
   readPools,
   readProfile,
   readProvider,
+  readRcSelfHostRecord,
   readUsageSnapshot,
   realConnectCertStore,
   realConnectEffects,
@@ -10585,6 +11363,7 @@ function prepareClaudeLaunch(options) {
   runCheck,
   runDoctor,
   runFrontDoorSupervisor,
+  runLauncher,
   runSupervisor,
   servedByPipeline,
   setAllowAmbientCredential,
@@ -10599,6 +11378,7 @@ function prepareClaudeLaunch(options) {
   setRcSessionModel,
   setRcSessionPermissionMode,
   snapshotPath,
+  spawnClaude,
   startConnectServer,
   topLevelNames,
   updateDirectoryRule,