agent-shim 8.22.0 → 8.24.0

package/dist/cli.cjs

@@ -55361,6 +55361,11 @@ var FrontDoorGlobalConfigSchema = external_exports.strictObject({
   /** How long the front door may sit with no registered sessions before it closes and exits. Defaults to FRONTDOOR_DEFAULT_IDLE_SHUTDOWN_MINUTES. */
   idleShutdownMinutes: external_exports.number().int().positive().optional()
 });
+var UPDATE_MODES = ["off", "notify", "auto"];
+var UpdateGlobalConfigSchema = external_exports.strictObject({
+  /** What a launch does about a newer release of agent-shim itself; see `UPDATE_MODES`. Absent means `off`. */
+  mode: external_exports.enum(UPDATE_MODES).optional()
+});
 var GlobalConfigSchema = external_exports.strictObject({
   $schema: external_exports.string().optional(),
   defaultConfigProfile: external_exports.string().min(1).optional(),
@@ -55370,6 +55375,7 @@ var GlobalConfigSchema = external_exports.strictObject({
   launch: LaunchSchema.optional(),
   headroom: HeadroomGlobalConfigSchema.optional(),
   frontdoor: FrontDoorGlobalConfigSchema.optional(),
+  update: UpdateGlobalConfigSchema.optional(),
   pools: external_exports.record(PoolNameSchema, PoolSchema).optional()
 });
 var IdentitySchema = external_exports.strictObject({
@@ -61790,7 +61796,7 @@ function registerIdentityCommand(program2, deps) {
 // package.json
 var package_default = {
   name: "agent-shim",
-  version: "8.22.0",
+  version: "8.24.0",
   description: "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
   license: "MIT",
   author: "Joseph Mearman <joseph@mearman.co.uk>",
@@ -64379,12 +64385,12 @@ var SiwcInvalidGrantError = class extends SiwcError {
 function base64Url(bytes) {
   return Buffer.from(bytes).toString("base64url");
 }
-function newPkce(randomBytes4) {
-  const verifier = base64Url(randomBytes4(SIWC_RANDOM_BYTES));
+function newPkce(randomBytes5) {
+  const verifier = base64Url(randomBytes5(SIWC_RANDOM_BYTES));
   return { verifier, challenge: (0, import_node_crypto6.createHash)("sha256").update(verifier).digest("base64url") };
 }
-function newOpaqueValue(randomBytes4) {
-  return base64Url(randomBytes4(SIWC_RANDOM_BYTES));
+function newOpaqueValue(randomBytes5) {
+  return base64Url(randomBytes5(SIWC_RANDOM_BYTES));
 }
 function buildAuthorizeUrl(request7) {
   const url2 = new URL(SIWC_AUTHORIZE_URL);
@@ -65045,7 +65051,7 @@ function registerCodexCommand(program2, deps) {
 }
 
 // src/frontdoor/commands.ts
-var import_node_crypto14 = require("node:crypto");
+var import_node_crypto15 = require("node:crypto");
 var import_node_path36 = __toESM(require("node:path"), 1);
 var import_node_fs13 = __toESM(require("node:fs"), 1);
 
@@ -66542,6 +66548,8 @@ function teeRoutedResponse(response, observer, onSettled) {
     }
   };
 }
+
+// src/frontdoor/rcWrites.ts
 function buildRcUserMessagePayload(uuid3, sessionId, text2) {
   return {
     type: "user",
@@ -66642,14 +66650,55 @@ var RC_PERMISSION_MODES = ["default", "acceptEdits", "bypassPermissions", "plan"
 function isRcPermissionMode(value2) {
   return RC_PERMISSION_MODES.some((mode) => mode === value2);
 }
+function buildRcControlRequestPayload(requestId, request7) {
+  return { type: "control_request", request_id: requestId, request: request7 };
+}
 function buildRcInterruptPayload(requestId) {
-  return { type: "control_request", request_id: requestId, request: { subtype: "interrupt" } };
+  return buildRcControlRequestPayload(requestId, { subtype: "interrupt" });
 }
 function buildRcSetModelPayload(requestId, model) {
-  return { type: "control_request", request_id: requestId, request: { subtype: "set_model", model } };
+  return buildRcControlRequestPayload(requestId, { subtype: "set_model", model });
 }
 function buildRcSetPermissionModePayload(requestId, mode) {
-  return { type: "control_request", request_id: requestId, request: { subtype: "set_permission_mode", mode } };
+  return buildRcControlRequestPayload(requestId, { subtype: "set_permission_mode", mode });
+}
+function buildRcEndSessionPayload(requestId, reason) {
+  return buildRcControlRequestPayload(requestId, { subtype: "end_session", ...reason === void 0 ? {} : { reason } });
+}
+function buildRcGetUsagePayload(requestId, skipBehaviors) {
+  return buildRcControlRequestPayload(requestId, { subtype: "get_usage", ...skipBehaviors === true ? { skip_behaviors: true } : {} });
+}
+var RC_CONTEXT_USAGE_DETAILS = ["summary", "full"];
+function isRcContextUsageDetail(value2) {
+  return RC_CONTEXT_USAGE_DETAILS.some((detail) => detail === value2);
+}
+function buildRcGetContextUsagePayload(requestId, detail) {
+  return buildRcControlRequestPayload(requestId, { subtype: "get_context_usage", ...detail === void 0 ? {} : { detail } });
+}
+var RC_READ_FILE_ENCODINGS = ["utf-8", "base64"];
+function isRcReadFileEncoding(value2) {
+  return RC_READ_FILE_ENCODINGS.some((encoding) => encoding === value2);
+}
+function buildRcReadFilePayload(requestId, path46, options) {
+  return buildRcControlRequestPayload(requestId, { subtype: "read_file", path: path46, ...options?.maxBytes === void 0 ? {} : { max_bytes: options.maxBytes }, ...options?.encoding === void 0 ? {} : { encoding: options.encoding } });
+}
+function buildRcFileSuggestionsPayload(requestId, query) {
+  return buildRcControlRequestPayload(requestId, { subtype: "file_suggestions", query });
+}
+function buildRcMcpStatusPayload(requestId) {
+  return buildRcControlRequestPayload(requestId, { subtype: "mcp_status" });
+}
+function buildRcMcpReconnectPayload(requestId, serverName) {
+  return buildRcControlRequestPayload(requestId, { subtype: "mcp_reconnect", serverName });
+}
+function buildRcMcpAuthenticatePayload(requestId, serverName, redirectUri) {
+  return buildRcControlRequestPayload(requestId, { subtype: "mcp_authenticate", serverName, redirectUri });
+}
+function buildRcMcpOAuthCallbackUrlPayload(requestId, serverName, callbackUrl) {
+  return buildRcControlRequestPayload(requestId, { subtype: "mcp_oauth_callback_url", serverName, callbackUrl });
+}
+function buildRcKeepAlivePayload() {
+  return { type: "keep_alive" };
 }
 async function answerRcControlRequest(deps, sessionId, requestId, decision) {
   const credential = deps.credentialOf(sessionId);
@@ -66676,7 +66725,7 @@ async function answerRcControlRequest(deps, sessionId, requestId, decision) {
   }
   return result;
 }
-async function interruptRcSession(deps, sessionId) {
+async function deliverRcClientPayload(deps, sessionId, payload, action) {
   const credential = deps.credentialOf(sessionId);
   if (credential === void 0) {
     return { ok: false, message: rcSessionNotObservedMessage(sessionId) };
@@ -66684,12 +66733,12 @@ async function interruptRcSession(deps, sessionId) {
   if (credential.authorization === void 0) {
     return noOAuthCredentialResult(sessionId);
   }
-  const body = JSON.stringify(buildRcEventWriteBody(buildRcInterruptPayload(deps.newUuid())));
+  const body = JSON.stringify(buildRcEventWriteBody(payload));
   let answer;
   try {
     answer = await deps.dial.writeEvents(sessionId, rcWriteHeaders(credential), body);
   } catch (error62) {
-    return { ok: false, message: `the door could not reach the API host to interrupt session ${sessionId}: ${error62 instanceof Error ? error62.message : String(error62)}` };
+    return { ok: false, message: `the door could not reach the API host to ${action}: ${error62 instanceof Error ? error62.message : String(error62)}` };
   }
   const result = rcEventWriteResultFromAnswer(answer);
   if (result.ok) {
@@ -66697,50 +66746,89 @@ async function interruptRcSession(deps, sessionId) {
   }
   return result;
 }
+async function interruptRcSession(deps, sessionId) {
+  const requestId = deps.newUuid();
+  const result = await deliverRcClientPayload(deps, sessionId, buildRcInterruptPayload(requestId), `interrupt session ${sessionId}`);
+  return result.ok ? { ...result, requestId } : result;
+}
 async function setRcSessionModel(deps, sessionId, model) {
   if (model === "") {
     return { ok: false, message: "a set-model write needs a non-empty model id: the SDK's own field treats an omitted or null value as a reset to the session default, which this operation never sends, and an empty string is neither" };
   }
-  const credential = deps.credentialOf(sessionId);
-  if (credential === void 0) {
-    return { ok: false, message: rcSessionNotObservedMessage(sessionId) };
-  }
-  if (credential.authorization === void 0) {
-    return noOAuthCredentialResult(sessionId);
+  const requestId = deps.newUuid();
+  const result = await deliverRcClientPayload(deps, sessionId, buildRcSetModelPayload(requestId, model), `set the model on session ${sessionId}`);
+  return result.ok ? { ...result, requestId } : result;
+}
+async function setRcSessionPermissionMode(deps, sessionId, mode) {
+  const requestId = deps.newUuid();
+  const result = await deliverRcClientPayload(deps, sessionId, buildRcSetPermissionModePayload(requestId, mode), `set the permission mode on session ${sessionId}`);
+  return result.ok ? { ...result, requestId } : result;
+}
+async function endRcSession(deps, sessionId, reason) {
+  if (reason === "") {
+    return { ok: false, message: "an end-session write needs either no reason or a non-empty one: the worker reads an absent reason as its own unspecified form, and an empty string is neither" };
   }
-  const body = JSON.stringify(buildRcEventWriteBody(buildRcSetModelPayload(deps.newUuid(), model)));
-  let answer;
-  try {
-    answer = await deps.dial.writeEvents(sessionId, rcWriteHeaders(credential), body);
-  } catch (error62) {
-    return { ok: false, message: `the door could not reach the API host to set the model on session ${sessionId}: ${error62 instanceof Error ? error62.message : String(error62)}` };
+  const requestId = deps.newUuid();
+  const result = await deliverRcClientPayload(deps, sessionId, buildRcEndSessionPayload(requestId, reason), `end session ${sessionId}`);
+  return result.ok ? { ...result, requestId } : result;
+}
+async function getRcSessionUsage(deps, sessionId, skipBehaviors) {
+  const requestId = deps.newUuid();
+  const result = await deliverRcClientPayload(deps, sessionId, buildRcGetUsagePayload(requestId, skipBehaviors), `request the usage of session ${sessionId}`);
+  return result.ok ? { ...result, requestId } : result;
+}
+async function getRcSessionContextUsage(deps, sessionId, detail) {
+  const requestId = deps.newUuid();
+  const result = await deliverRcClientPayload(deps, sessionId, buildRcGetContextUsagePayload(requestId, detail), `request the context usage of session ${sessionId}`);
+  return result.ok ? { ...result, requestId } : result;
+}
+async function readRcSessionFile(deps, sessionId, path46, options) {
+  if (path46 === "") {
+    return { ok: false, message: "a read-file write needs a non-empty path: the SDK's own field names the file the worker resolves against the session's cwd, and an empty string names none" };
   }
-  const result = rcEventWriteResultFromAnswer(answer);
-  if (result.ok) {
-    deps.noteSequenceNums(sessionId, result.sequenceNums);
+  if (options?.maxBytes !== void 0 && (!Number.isInteger(options.maxBytes) || options.maxBytes <= 0)) {
+    return { ok: false, message: "a read-file write's max-bytes is a positive whole number of bytes: the SDK's own field caps the read, and a zero or negative cap reads nothing" };
   }
-  return result;
+  const requestId = deps.newUuid();
+  const result = await deliverRcClientPayload(deps, sessionId, buildRcReadFilePayload(requestId, path46, options), `read ${path46} from session ${sessionId}`);
+  return result.ok ? { ...result, requestId } : result;
 }
-async function setRcSessionPermissionMode(deps, sessionId, mode) {
-  const credential = deps.credentialOf(sessionId);
-  if (credential === void 0) {
-    return { ok: false, message: rcSessionNotObservedMessage(sessionId) };
-  }
-  if (credential.authorization === void 0) {
-    return noOAuthCredentialResult(sessionId);
+async function suggestRcSessionFiles(deps, sessionId, query) {
+  const requestId = deps.newUuid();
+  const result = await deliverRcClientPayload(deps, sessionId, buildRcFileSuggestionsPayload(requestId, query), `request file suggestions from session ${sessionId}`);
+  return result.ok ? { ...result, requestId } : result;
+}
+async function getRcSessionMcpStatus(deps, sessionId) {
+  const requestId = deps.newUuid();
+  const result = await deliverRcClientPayload(deps, sessionId, buildRcMcpStatusPayload(requestId), `request the MCP status of session ${sessionId}`);
+  return result.ok ? { ...result, requestId } : result;
+}
+async function reconnectRcSessionMcpServer(deps, sessionId, serverName) {
+  if (serverName === "") {
+    return { ok: false, message: "an mcp-reconnect write needs a non-empty server name: the SDK's own field names the server as mcp_status reports it, and an empty string names none" };
   }
-  const body = JSON.stringify(buildRcEventWriteBody(buildRcSetPermissionModePayload(deps.newUuid(), mode)));
-  let answer;
-  try {
-    answer = await deps.dial.writeEvents(sessionId, rcWriteHeaders(credential), body);
-  } catch (error62) {
-    return { ok: false, message: `the door could not reach the API host to set the permission mode on session ${sessionId}: ${error62 instanceof Error ? error62.message : String(error62)}` };
+  const requestId = deps.newUuid();
+  const result = await deliverRcClientPayload(deps, sessionId, buildRcMcpReconnectPayload(requestId, serverName), `reconnect MCP server ${serverName} on session ${sessionId}`);
+  return result.ok ? { ...result, requestId } : result;
+}
+async function authenticateRcSessionMcpServer(deps, sessionId, serverName, redirectUri) {
+  if (serverName === "" || redirectUri === "") {
+    return { ok: false, message: "an mcp-authenticate write needs a non-empty server name and redirect URI: the CLI's own request names the server and where its OAuth flow redirects back to, and an empty string names neither" };
   }
-  const result = rcEventWriteResultFromAnswer(answer);
-  if (result.ok) {
-    deps.noteSequenceNums(sessionId, result.sequenceNums);
+  const requestId = deps.newUuid();
+  const result = await deliverRcClientPayload(deps, sessionId, buildRcMcpAuthenticatePayload(requestId, serverName, redirectUri), `authenticate MCP server ${serverName} on session ${sessionId}`);
+  return result.ok ? { ...result, requestId } : result;
+}
+async function submitRcSessionMcpOAuthCallbackUrl(deps, sessionId, serverName, callbackUrl) {
+  if (serverName === "" || callbackUrl === "") {
+    return { ok: false, message: "an mcp-oauth-callback-url write needs a non-empty server name and callback URL: the CLI's own request names the server and the URL its OAuth flow landed on, and an empty string names neither" };
   }
-  return result;
+  const requestId = deps.newUuid();
+  const result = await deliverRcClientPayload(deps, sessionId, buildRcMcpOAuthCallbackUrlPayload(requestId, serverName, callbackUrl), `hand MCP server ${serverName}'s OAuth callback to session ${sessionId}`);
+  return result.ok ? { ...result, requestId } : result;
+}
+async function sendRcKeepAlive(deps, sessionId) {
+  return await deliverRcClientPayload(deps, sessionId, buildRcKeepAlivePayload(), `keep session ${sessionId} alive`);
 }
 
 // src/frontdoor/rcControl.ts
@@ -66752,6 +66840,25 @@ function answerJson(response, status, body) {
   response.writeHead(status, { "content-type": "application/json", "content-length": String(Buffer.byteLength(text2, "utf8")) });
   response.end(text2);
 }
+function isJsonObject(value2) {
+  return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
+}
+function bodyString(body, field) {
+  const value2 = body[field];
+  return typeof value2 === "string" && value2 !== "" ? value2 : void 0;
+}
+function bodyStringAllowingEmpty(body, field) {
+  const value2 = body[field];
+  return typeof value2 === "string" ? value2 : void 0;
+}
+function bodyBoolean(body, field) {
+  const value2 = body[field];
+  return typeof value2 === "boolean" ? value2 : void 0;
+}
+function bodyPositiveInteger(body, field) {
+  const value2 = body[field];
+  return typeof value2 === "number" && Number.isInteger(value2) && value2 > 0 ? value2 : void 0;
+}
 async function readBody(request7) {
   return await new Promise((resolve, reject) => {
     const chunks = [];
@@ -66779,9 +66886,127 @@ function createRcControlHandler(deps) {
   const pendingPath = `${CONTROL_PATH_PREFIX}/pending`;
   const injectPath = `${CONTROL_PATH_PREFIX}/inject`;
   const answerPath = `${CONTROL_PATH_PREFIX}/answer`;
-  const interruptPath = `${CONTROL_PATH_PREFIX}/interrupt`;
-  const setModelPath = `${CONTROL_PATH_PREFIX}/set-model`;
-  const setPermissionModePath = `${CONTROL_PATH_PREFIX}/set-permission-mode`;
+  const controlWrites = [
+    {
+      name: "interrupt",
+      path: "interrupt",
+      read: (body) => {
+        const session = bodyString(body, "session");
+        return session === void 0 ? { error: "the interrupt body must be JSON naming a non-empty session id" } : { session, run: async () => await deps.interrupt(session) };
+      }
+    },
+    {
+      name: "set-model",
+      path: "set-model",
+      read: (body) => {
+        const session = bodyString(body, "session");
+        const model = bodyString(body, "model");
+        return session === void 0 || model === void 0 ? { error: "the set-model body must be JSON naming a non-empty session id and model id" } : { session, run: async () => await deps.setModel(session, model) };
+      }
+    },
+    {
+      name: "set-permission-mode",
+      path: "set-permission-mode",
+      read: (body) => {
+        const session = bodyString(body, "session");
+        const mode = body.mode;
+        return session === void 0 || !isRcPermissionMode(mode) ? { error: `the set-permission-mode body must be JSON naming a non-empty session id and a mode the SDK's own type permits (${RC_PERMISSION_MODE_LIST})` } : { session, run: async () => await deps.setPermissionMode(session, mode) };
+      }
+    },
+    {
+      name: "end-session",
+      path: "end-session",
+      read: (body) => {
+        const session = bodyString(body, "session");
+        const reason = "reason" in body ? bodyString(body, "reason") : void 0;
+        return session === void 0 || "reason" in body && reason === void 0 ? { error: "the end-session body must be JSON naming a non-empty session id, and a reason only as a non-empty string or absent" } : { session, run: async () => await deps.endSession(session, reason) };
+      }
+    },
+    {
+      name: "get-usage",
+      path: "get-usage",
+      read: (body) => {
+        const session = bodyString(body, "session");
+        const skipBehaviors = "skipBehaviors" in body ? bodyBoolean(body, "skipBehaviors") : void 0;
+        return session === void 0 || "skipBehaviors" in body && skipBehaviors === void 0 ? { error: "the get-usage body must be JSON naming a non-empty session id, and skipBehaviors only as a boolean or absent" } : { session, run: async () => await deps.getUsage(session, skipBehaviors) };
+      }
+    },
+    {
+      name: "get-context-usage",
+      path: "get-context-usage",
+      read: (body) => {
+        const session = bodyString(body, "session");
+        const detail = "detail" in body && isRcContextUsageDetail(body.detail) ? body.detail : void 0;
+        return session === void 0 || "detail" in body && detail === void 0 ? { error: `the get-context-usage body must be JSON naming a non-empty session id, and a detail level the SDK's own type permits (${RC_CONTEXT_USAGE_DETAILS.join(", ")}) or none` } : { session, run: async () => await deps.getContextUsage(session, detail) };
+      }
+    },
+    {
+      name: "read-file",
+      path: "read-file",
+      read: (body) => {
+        const session = bodyString(body, "session");
+        const path46 = bodyString(body, "path");
+        const maxBytes = "maxBytes" in body ? bodyPositiveInteger(body, "maxBytes") : void 0;
+        const encoding = "encoding" in body && isRcReadFileEncoding(body.encoding) ? body.encoding : void 0;
+        const refused2 = session === void 0 || path46 === void 0 || "maxBytes" in body && maxBytes === void 0 || "encoding" in body && encoding === void 0;
+        return refused2 ? { error: `the read-file body must be JSON naming a non-empty session id and path, maxBytes only as a positive whole number or absent, and an encoding the SDK's own type permits (${RC_READ_FILE_ENCODINGS.join(", ")}) or none` } : { session, run: async () => await deps.readFile(session, path46, { ...maxBytes === void 0 ? {} : { maxBytes }, ...encoding === void 0 ? {} : { encoding } }) };
+      }
+    },
+    {
+      name: "file-suggestions",
+      path: "file-suggestions",
+      read: (body) => {
+        const session = bodyString(body, "session");
+        const query = bodyStringAllowingEmpty(body, "query");
+        return session === void 0 || query === void 0 ? { error: "the file-suggestions body must be JSON naming a non-empty session id and a query string, which may be empty" } : { session, run: async () => await deps.fileSuggestions(session, query) };
+      }
+    },
+    {
+      name: "keep-alive",
+      path: "keep-alive",
+      read: (body) => {
+        const session = bodyString(body, "session");
+        return session === void 0 ? { error: "the keep-alive body must be JSON naming a non-empty session id" } : { session, run: async () => await deps.keepAlive(session) };
+      }
+    },
+    {
+      name: "mcp-status",
+      path: "mcp-status",
+      read: (body) => {
+        const session = bodyString(body, "session");
+        return session === void 0 ? { error: "the mcp-status body must be JSON naming a non-empty session id" } : { session, run: async () => await deps.mcpStatus(session) };
+      }
+    },
+    {
+      name: "mcp-reconnect",
+      path: "mcp-reconnect",
+      read: (body) => {
+        const session = bodyString(body, "session");
+        const serverName = bodyString(body, "serverName");
+        return session === void 0 || serverName === void 0 ? { error: "the mcp-reconnect body must be JSON naming a non-empty session id and server name" } : { session, run: async () => await deps.mcpReconnect(session, serverName) };
+      }
+    },
+    {
+      name: "mcp-authenticate",
+      path: "mcp-authenticate",
+      read: (body) => {
+        const session = bodyString(body, "session");
+        const serverName = bodyString(body, "serverName");
+        const redirectUri = bodyString(body, "redirectUri");
+        return session === void 0 || serverName === void 0 || redirectUri === void 0 ? { error: "the mcp-authenticate body must be JSON naming a non-empty session id, server name, and redirect URI" } : { session, run: async () => await deps.mcpAuthenticate(session, serverName, redirectUri) };
+      }
+    },
+    {
+      name: "mcp-oauth-callback-url",
+      path: "mcp-oauth-callback-url",
+      read: (body) => {
+        const session = bodyString(body, "session");
+        const serverName = bodyString(body, "serverName");
+        const callbackUrl = bodyString(body, "callbackUrl");
+        return session === void 0 || serverName === void 0 || callbackUrl === void 0 ? { error: "the mcp-oauth-callback-url body must be JSON naming a non-empty session id, server name, and callback URL" } : { session, run: async () => await deps.mcpOAuthCallbackUrl(session, serverName, callbackUrl) };
+      }
+    }
+  ];
   return (request7, response) => {
     const presented = request7.headers.authorization;
     const bearerPrefix = "bearer ".length;
@@ -66866,73 +67091,33 @@ function createRcControlHandler(deps) {
         answerJson(response, HTTP_STATUS.badGateway, { error: result.message });
         return;
       }
-      if (url2.pathname === interruptPath) {
-        if (request7.method !== "POST") {
-          answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the interrupt operation is a POST" });
-          return;
-        }
-        let parsed;
-        try {
-          parsed = JSON.parse(await readBody(request7));
-        } catch {
-          answerJson(response, HTTP_STATUS.badRequest, { error: "the interrupt body is not readable JSON within the control body cap" });
-          return;
-        }
-        if (typeof parsed !== "object" || parsed === null || !("session" in parsed) || typeof parsed.session !== "string" || parsed.session === "") {
-          answerJson(response, HTTP_STATUS.badRequest, { error: "the interrupt body must be JSON naming a non-empty session id" });
-          return;
-        }
-        const result = await deps.interrupt(parsed.session);
-        if (result.ok) {
-          answerJson(response, HTTP_STATUS.ok, { session: parsed.session, sequenceNums: result.sequenceNums });
-          return;
+      for (const route of controlWrites) {
+        if (url2.pathname !== `${CONTROL_PATH_PREFIX}/${route.path}`) {
+          continue;
         }
-        answerJson(response, HTTP_STATUS.badGateway, { error: result.message });
-        return;
-      }
-      if (url2.pathname === setModelPath) {
         if (request7.method !== "POST") {
-          answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the set-model operation is a POST" });
+          answerJson(response, HTTP_STATUS.methodNotAllowed, { error: `the ${route.name} operation is a POST` });
           return;
         }
         let parsed;
         try {
           parsed = JSON.parse(await readBody(request7));
         } catch {
-          answerJson(response, HTTP_STATUS.badRequest, { error: "the set-model body is not readable JSON within the control body cap" });
-          return;
-        }
-        if (typeof parsed !== "object" || parsed === null || !("session" in parsed) || !("model" in parsed) || typeof parsed.session !== "string" || typeof parsed.model !== "string" || parsed.session === "" || parsed.model === "") {
-          answerJson(response, HTTP_STATUS.badRequest, { error: "the set-model body must be JSON naming a non-empty session id and model id" });
+          answerJson(response, HTTP_STATUS.badRequest, { error: `the ${route.name} body is not readable JSON within the control body cap` });
           return;
         }
-        const result = await deps.setModel(parsed.session, parsed.model);
-        if (result.ok) {
-          answerJson(response, HTTP_STATUS.ok, { session: parsed.session, model: parsed.model, sequenceNums: result.sequenceNums });
-          return;
-        }
-        answerJson(response, HTTP_STATUS.badGateway, { error: result.message });
-        return;
-      }
-      if (url2.pathname === setPermissionModePath) {
-        if (request7.method !== "POST") {
-          answerJson(response, HTTP_STATUS.methodNotAllowed, { error: "the set-permission-mode operation is a POST" });
-          return;
-        }
-        let parsed;
-        try {
-          parsed = JSON.parse(await readBody(request7));
-        } catch {
-          answerJson(response, HTTP_STATUS.badRequest, { error: "the set-permission-mode body is not readable JSON within the control body cap" });
+        if (!isJsonObject(parsed)) {
+          answerJson(response, HTTP_STATUS.badRequest, { error: `the ${route.name} body must be a JSON object` });
           return;
         }
-        if (typeof parsed !== "object" || parsed === null || !("session" in parsed) || !("mode" in parsed) || typeof parsed.session !== "string" || parsed.session === "" || !isRcPermissionMode(parsed.mode)) {
-          answerJson(response, HTTP_STATUS.badRequest, { error: `the set-permission-mode body must be JSON naming a non-empty session id and a mode the SDK's own type permits (${RC_PERMISSION_MODE_LIST})` });
+        const read = route.read(parsed);
+        if ("error" in read) {
+          answerJson(response, HTTP_STATUS.badRequest, { error: read.error });
           return;
         }
-        const result = await deps.setPermissionMode(parsed.session, parsed.mode);
+        const result = await read.run();
         if (result.ok) {
-          answerJson(response, HTTP_STATUS.ok, { session: parsed.session, mode: parsed.mode, sequenceNums: result.sequenceNums });
+          answerJson(response, HTTP_STATUS.ok, { session: read.session, ...result.requestId === void 0 ? {} : { request: result.requestId }, sequenceNums: result.sequenceNums });
           return;
         }
         answerJson(response, HTTP_STATUS.badGateway, { error: result.message });
@@ -67050,6 +67235,19 @@ function sequenceNumsOfBody(body) {
   }
   return sequenceNums;
 }
+function requestIdOfBody(body) {
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return void 0;
+  }
+  if (typeof parsed !== "object" || parsed === null || !("request" in parsed)) {
+    return void 0;
+  }
+  const value2 = parsed.request;
+  return typeof value2 === "string" && value2 !== "" ? value2 : void 0;
+}
 function frontDoorRcControl(transport, token) {
   const headers = { authorization: `Bearer ${token}` };
   const listAnswerOf = async (path46, what) => {
@@ -67138,7 +67336,8 @@ function frontDoorRcControl(transport, token) {
       if (sequenceNums === void 0) {
         return { ok: false, message: `the door accepted the event but its answer named no sequence numbers: ${answer.body}` };
       }
-      return { ok: true, sequenceNums };
+      const requestId = requestIdOfBody(answer.body);
+      return requestId === void 0 ? { ok: true, sequenceNums } : { ok: true, sequenceNums, requestId };
     }
     return { ok: false, message: describeFailure(answer.status, controlErrorOf(answer.body) ?? answer.body) };
   };
@@ -67155,7 +67354,21 @@ function frontDoorRcControl(transport, token) {
     ),
     interruptSession: async (sessionId) => await writeOf(`${CONTROL_PATH_PREFIX}/interrupt`, JSON.stringify({ session: sessionId }), (status, message) => `interrupting ${sessionId} failed (HTTP ${String(status)}): ${message}`),
     setModel: async (sessionId, model) => await writeOf(`${CONTROL_PATH_PREFIX}/set-model`, JSON.stringify({ session: sessionId, model }), (status, message) => `setting the model on ${sessionId} failed (HTTP ${String(status)}): ${message}`),
-    setPermissionMode: async (sessionId, mode) => await writeOf(`${CONTROL_PATH_PREFIX}/set-permission-mode`, JSON.stringify({ session: sessionId, mode }), (status, message) => `setting the permission mode on ${sessionId} failed (HTTP ${String(status)}): ${message}`)
+    setPermissionMode: async (sessionId, mode) => await writeOf(`${CONTROL_PATH_PREFIX}/set-permission-mode`, JSON.stringify({ session: sessionId, mode }), (status, message) => `setting the permission mode on ${sessionId} failed (HTTP ${String(status)}): ${message}`),
+    endSession: async (sessionId, reason) => await writeOf(`${CONTROL_PATH_PREFIX}/end-session`, JSON.stringify({ session: sessionId, ...reason === void 0 ? {} : { reason } }), (status, message) => `ending ${sessionId} failed (HTTP ${String(status)}): ${message}`),
+    getUsage: async (sessionId, skipBehaviors) => await writeOf(`${CONTROL_PATH_PREFIX}/get-usage`, JSON.stringify({ session: sessionId, ...skipBehaviors === void 0 ? {} : { skipBehaviors } }), (status, message) => `requesting the usage of ${sessionId} failed (HTTP ${String(status)}): ${message}`),
+    getContextUsage: async (sessionId, detail) => await writeOf(`${CONTROL_PATH_PREFIX}/get-context-usage`, JSON.stringify({ session: sessionId, ...detail === void 0 ? {} : { detail } }), (status, message) => `requesting the context usage of ${sessionId} failed (HTTP ${String(status)}): ${message}`),
+    readFile: async (sessionId, path46, options) => await writeOf(
+      `${CONTROL_PATH_PREFIX}/read-file`,
+      JSON.stringify({ session: sessionId, path: path46, ...options?.maxBytes === void 0 ? {} : { maxBytes: options.maxBytes }, ...options?.encoding === void 0 ? {} : { encoding: options.encoding } }),
+      (status, message) => `reading ${path46} from ${sessionId} failed (HTTP ${String(status)}): ${message}`
+    ),
+    fileSuggestions: async (sessionId, query) => await writeOf(`${CONTROL_PATH_PREFIX}/file-suggestions`, JSON.stringify({ session: sessionId, query }), (status, message) => `requesting file suggestions from ${sessionId} failed (HTTP ${String(status)}): ${message}`),
+    keepAlive: async (sessionId) => await writeOf(`${CONTROL_PATH_PREFIX}/keep-alive`, JSON.stringify({ session: sessionId }), (status, message) => `keeping ${sessionId} alive failed (HTTP ${String(status)}): ${message}`),
+    mcpStatus: async (sessionId) => await writeOf(`${CONTROL_PATH_PREFIX}/mcp-status`, JSON.stringify({ session: sessionId }), (status, message) => `requesting the MCP status of ${sessionId} failed (HTTP ${String(status)}): ${message}`),
+    mcpReconnect: async (sessionId, serverName) => await writeOf(`${CONTROL_PATH_PREFIX}/mcp-reconnect`, JSON.stringify({ session: sessionId, serverName }), (status, message) => `reconnecting MCP server ${serverName} on ${sessionId} failed (HTTP ${String(status)}): ${message}`),
+    mcpAuthenticate: async (sessionId, serverName, redirectUri) => await writeOf(`${CONTROL_PATH_PREFIX}/mcp-authenticate`, JSON.stringify({ session: sessionId, serverName, redirectUri }), (status, message) => `authenticating MCP server ${serverName} on ${sessionId} failed (HTTP ${String(status)}): ${message}`),
+    mcpOAuthCallbackUrl: async (sessionId, serverName, callbackUrl) => await writeOf(`${CONTROL_PATH_PREFIX}/mcp-oauth-callback-url`, JSON.stringify({ session: sessionId, serverName, callbackUrl }), (status, message) => `handing MCP server ${serverName}'s OAuth callback to ${sessionId} failed (HTTP ${String(status)}): ${message}`)
   };
 }
 
@@ -71819,6 +72032,48 @@ var RcSetPermissionModeInputSchema = external_exports.strictObject({
   session: external_exports.string().min(1),
   mode: RcPermissionModeSchema
 });
+var RcEndSessionInputSchema = external_exports.strictObject({
+  session: external_exports.string().min(1),
+  reason: external_exports.string().min(1).optional()
+});
+var RcGetUsageInputSchema = external_exports.strictObject({
+  session: external_exports.string().min(1),
+  skipBehaviors: external_exports.boolean().optional()
+});
+var RcGetContextUsageInputSchema = external_exports.strictObject({
+  session: external_exports.string().min(1),
+  detail: external_exports.enum(RC_CONTEXT_USAGE_DETAILS).optional()
+});
+var RcReadFileInputSchema = external_exports.strictObject({
+  session: external_exports.string().min(1),
+  path: external_exports.string().min(1),
+  maxBytes: external_exports.number().int().positive().optional(),
+  encoding: external_exports.enum(RC_READ_FILE_ENCODINGS).optional()
+});
+var RcFileSuggestionsInputSchema = external_exports.strictObject({
+  session: external_exports.string().min(1),
+  query: external_exports.string()
+});
+var RcKeepAliveInputSchema = external_exports.strictObject({
+  session: external_exports.string().min(1)
+});
+var RcMcpStatusInputSchema = external_exports.strictObject({
+  session: external_exports.string().min(1)
+});
+var RcMcpReconnectInputSchema = external_exports.strictObject({
+  session: external_exports.string().min(1),
+  serverName: external_exports.string().min(1)
+});
+var RcMcpAuthenticateInputSchema = external_exports.strictObject({
+  session: external_exports.string().min(1),
+  serverName: external_exports.string().min(1),
+  redirectUri: external_exports.string().min(1)
+});
+var RcMcpOAuthCallbackUrlInputSchema = external_exports.strictObject({
+  session: external_exports.string().min(1),
+  serverName: external_exports.string().min(1),
+  callbackUrl: external_exports.string().min(1)
+});
 var RcListOutputSchema = external_exports.strictObject({ sessions: external_exports.readonly(external_exports.array(RcSessionSummarySchema)) });
 var RcStatusOutputSchema = external_exports.strictObject({ statuses: external_exports.readonly(external_exports.array(RcSessionStatusSchema)) });
 var RcPendingOutputSchema = external_exports.strictObject({ pending: external_exports.readonly(external_exports.array(RcPendingRequestSummarySchema)) });
@@ -71826,6 +72081,11 @@ var RcWriteOutputSchema = external_exports.strictObject({
   session: external_exports.string(),
   sequenceNums: external_exports.readonly(external_exports.array(external_exports.number()))
 });
+var RcControlWriteOutputSchema = external_exports.strictObject({
+  session: external_exports.string(),
+  request: external_exports.string(),
+  sequenceNums: external_exports.readonly(external_exports.array(external_exports.number()))
+});
 var RcAnswerOutputSchema = external_exports.strictObject({
   session: external_exports.string(),
   request: external_exports.string(),
@@ -71854,6 +72114,15 @@ function createRcApiRouter(deps) {
     }
     return result.sequenceNums;
   };
+  const deliveredControl = (sessionId, result) => {
+    if (!result.ok) {
+      throw new ORPCError("BAD_GATEWAY", { message: result.message });
+    }
+    if (result.requestId === void 0) {
+      throw new ORPCError("INTERNAL_SERVER_ERROR", { message: "the control request was delivered but the door cannot name the request id it minted, so the worker's answer cannot be matched" });
+    }
+    return { request: result.requestId, sequenceNums: result.sequenceNums };
+  };
   return {
     rc: {
       list: authed.output(RcListOutputSchema).handler(() => ({ sessions: deps.list() })),
@@ -71876,9 +72145,19 @@ function createRcApiRouter(deps) {
         const decision = { approve: input2.approve, message: input2.approve || input2.text === void 0 ? void 0 : input2.text };
         return { session: input2.session, request: input2.request, sequenceNums: delivered(input2.session, await deps.answer(input2.session, input2.request, decision)) };
       }),
-      interrupt: authed.input(RcInterruptInputSchema).output(RcWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, sequenceNums: delivered(input2.session, await deps.interrupt(input2.session)) })),
-      setModel: authed.input(RcSetModelInputSchema).output(RcWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, sequenceNums: delivered(input2.session, await deps.setModel(input2.session, input2.model)) })),
-      setPermissionMode: authed.input(RcSetPermissionModeInputSchema).output(RcWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, sequenceNums: delivered(input2.session, await deps.setPermissionMode(input2.session, input2.mode)) })),
+      interrupt: authed.input(RcInterruptInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.interrupt(input2.session)) })),
+      setModel: authed.input(RcSetModelInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.setModel(input2.session, input2.model)) })),
+      setPermissionMode: authed.input(RcSetPermissionModeInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.setPermissionMode(input2.session, input2.mode)) })),
+      endSession: authed.input(RcEndSessionInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.endSession(input2.session, input2.reason)) })),
+      getUsage: authed.input(RcGetUsageInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.getUsage(input2.session, input2.skipBehaviors)) })),
+      getContextUsage: authed.input(RcGetContextUsageInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.getContextUsage(input2.session, input2.detail)) })),
+      readFile: authed.input(RcReadFileInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.readFile(input2.session, input2.path, { ...input2.maxBytes === void 0 ? {} : { maxBytes: input2.maxBytes }, ...input2.encoding === void 0 ? {} : { encoding: input2.encoding } })) })),
+      fileSuggestions: authed.input(RcFileSuggestionsInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.fileSuggestions(input2.session, input2.query)) })),
+      keepAlive: authed.input(RcKeepAliveInputSchema).output(RcWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, sequenceNums: delivered(input2.session, await deps.keepAlive(input2.session)) })),
+      mcpStatus: authed.input(RcMcpStatusInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.mcpStatus(input2.session)) })),
+      mcpReconnect: authed.input(RcMcpReconnectInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.mcpReconnect(input2.session, input2.serverName)) })),
+      mcpAuthenticate: authed.input(RcMcpAuthenticateInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.mcpAuthenticate(input2.session, input2.serverName, input2.redirectUri)) })),
+      mcpOAuthCallbackUrl: authed.input(RcMcpOAuthCallbackUrlInputSchema).output(RcControlWriteOutputSchema).handler(async ({ input: input2 }) => ({ session: input2.session, ...deliveredControl(input2.session, await deps.mcpOAuthCallbackUrl(input2.session, input2.serverName, input2.callbackUrl)) })),
       subscribe: authed.input(RcSessionQuerySchema).output(eventIterator(RcStreamEventSchema)).handler(async function* ({ input: input2, signal }) {
         const queue = [];
         let wake;
@@ -73453,1425 +73732,890 @@ function attachingProviderCredential(route, deps) {
   };
 }
 
-// src/frontdoor/rcCredentialStore.ts
+// src/frontdoor/rcCommands.ts
+var import_node_crypto14 = require("node:crypto");
+
+// src/frontdoor/rcSelfHostMint.ts
 var import_node_path34 = __toESM(require("node:path"), 1);
-function isSafeSessionId(sessionId) {
-  return /^[A-Za-z0-9_-]+$/.test(sessionId);
-}
-function isRecord4(value2) {
-  return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
-}
-function credentialOfJson(parsed) {
-  if (!isRecord4(parsed)) {
-    return void 0;
-  }
-  const { authorization, anthropicVersion, anthropicClientPlatform } = parsed;
-  if (typeof authorization !== "string" || authorization === "") {
-    return void 0;
-  }
-  return {
-    authorization,
-    anthropicVersion: typeof anthropicVersion === "string" ? anthropicVersion : void 0,
-    anthropicClientPlatform: typeof anthropicClientPlatform === "string" ? anthropicClientPlatform : void 0
-  };
+
+// src/frontdoor/rcWebFetch.ts
+var dns2 = __toESM(require("node:dns"), 1);
+var http6 = __toESM(require("node:http"), 1);
+var https5 = __toESM(require("node:https"), 1);
+var net3 = __toESM(require("node:net"), 1);
+var RC_WEB_FETCH_MAX_BYTES = 12582912;
+var RC_WEB_FETCH_DEADLINE_MS = 4e4;
+var RC_WEB_FETCH_MAX_REDIRECTS = 20;
+var RC_WEB_FETCH_ALLOW_PRIVATE_ENV = "AGENT_SHIM_FRONTDOOR_RC_SELF_HOST_WEB_FETCH_ALLOW_PRIVATE";
+function rcWebFetchAllowsPrivateFromEnv(env) {
+  return env[RC_WEB_FETCH_ALLOW_PRIVATE_ENV] === "1";
 }
-function sequenceNumOfJson(value2) {
-  return typeof value2 === "number" && Number.isInteger(value2) && value2 >= 0 ? value2 : void 0;
+var WEB_FETCH_USER_AGENT = "agent-shim-frontdoor";
+var ERROR_PREFIX = "web_fetch_";
+var V4_THIS_NETWORK_OCTET = 0;
+var V4_PRIVATE_A_OCTET = 10;
+var V4_LOOPBACK_OCTET = 127;
+var V4_CGNAT_OCTET = 100;
+var V4_CGNAT_SECOND_FROM = 64;
+var V4_CGNAT_SECOND_TO = 127;
+var V4_LINK_LOCAL_OCTET = 169;
+var V4_LINK_LOCAL_SECOND = 254;
+var V4_PRIVATE_B_OCTET = 172;
+var V4_PRIVATE_B_SECOND_FROM = 16;
+var V4_PRIVATE_B_SECOND_TO = 31;
+var V4_PRIVATE_C_OCTET = 192;
+var V4_PRIVATE_C_SECOND = 168;
+var V4_MULTICAST_FROM_OCTET = 224;
+var V6_UNIQUE_LOCAL_FROM = 64512;
+var V6_UNIQUE_LOCAL_TO = 65023;
+var V6_LINK_LOCAL_FROM = 65152;
+var V6_LINK_LOCAL_TO = 65215;
+var V6_MULTICAST_FROM = 65280;
+var IP_VERSION_4 = 4;
+var IP_VERSION_6 = 6;
+var HTTP_MOVED_PERMANENTLY = 301;
+var HTTP_FOUND = 302;
+var HTTP_SEE_OTHER = 303;
+var HTTP_TEMPORARY_REDIRECT = 307;
+var HTTP_PERMANENT_REDIRECT = 308;
+var SUCCESS_STATUS_MAX_EXCLUSIVE3 = 300;
+function refused(errorType, errorMessage2) {
+  return { kind: "refused", errorType: `${ERROR_PREFIX}${errorType}`, errorMessage: errorMessage2 };
 }
-function createRcCredentialStore(fs20, dir) {
-  fs20.mkdirPrivate(dir);
-  const fileFor = (sessionId) => import_node_path34.default.join(dir, `${sessionId}.json`);
-  const readParsed = (sessionId) => {
-    const raw = fs20.readFileUtf8(fileFor(sessionId));
-    if (raw === void 0) {
-      return void 0;
-    }
-    let parsed;
-    try {
-      parsed = JSON.parse(raw);
-    } catch {
-      return void 0;
+function isPrivateAddress(address) {
+  const version2 = net3.isIP(address);
+  if (version2 === IP_VERSION_4) {
+    const octets = address.split(".").map((part) => Number(part));
+    const first = octets[0] ?? -1;
+    const second = octets[1] ?? -1;
+    if (first === V4_THIS_NETWORK_OCTET || first === V4_PRIVATE_A_OCTET || first === V4_LOOPBACK_OCTET) {
+      return true;
     }
-    return isRecord4(parsed) ? parsed : void 0;
-  };
-  return {
-    read: (sessionId) => {
-      if (!isSafeSessionId(sessionId)) {
-        return void 0;
-      }
-      return credentialOfJson(readParsed(sessionId));
-    },
-    write: (sessionId, credential) => {
-      if (!isSafeSessionId(sessionId)) {
-        return;
-      }
-      const cursor3 = sequenceNumOfJson(readParsed(sessionId)?.highestSequenceNum);
-      const record2 = { ...credential, ...cursor3 === void 0 ? {} : { highestSequenceNum: cursor3 } };
-      fs20.writeFilePrivate(fileFor(sessionId), `${JSON.stringify(record2, null, 2)}
-`);
-    },
-    readCursor: (sessionId) => {
-      if (!isSafeSessionId(sessionId)) {
-        return void 0;
-      }
-      return sequenceNumOfJson(readParsed(sessionId)?.highestSequenceNum);
-    },
-    writeCursor: (sessionId, highestSequenceNum) => {
-      if (!isSafeSessionId(sessionId)) {
-        return;
-      }
-      const credential = credentialOfJson(readParsed(sessionId));
-      const record2 = credential === void 0 ? { highestSequenceNum } : { ...credential, highestSequenceNum };
-      fs20.writeFilePrivate(fileFor(sessionId), `${JSON.stringify(record2, null, 2)}
-`);
-    },
-    remove: (sessionId) => {
-      if (!isSafeSessionId(sessionId)) {
-        return;
-      }
-      fs20.removeRecursive(fileFor(sessionId));
+    if (first === V4_CGNAT_OCTET && second >= V4_CGNAT_SECOND_FROM && second <= V4_CGNAT_SECOND_TO) {
+      return true;
     }
-  };
-}
-
-// src/frontdoor/rcClientPage.ts
-var RC_CLIENT_PATH = "/__agent-shim/client";
-var RC_CLIENT_PAGE_SCRIPT = `'use strict';
-// The door's typed API as this page speaks it: the oRPC RPC protocol over plain fetch, which is one POST per procedure with a {"json": input} body and a {"json": output} answer, so no client library is needed. These helpers are plain top-level functions (not boot-scoped) so the page's tests can evaluate this script outside a browser and drive them against a mounted listener.
-var API_PREFIX = '/__agent-shim/orpc';
-var TOKEN_KEY = 'agent-shim-rc-token';
-var token = null;
-
-function apiBase() { return window.location.origin + API_PREFIX; }
-
-// Calls one procedure: resolves the output's own value, rejects with the door's error message when it answered one.
-async function rpc(path, input) {
-  var response = await fetch(apiBase() + '/' + path, {
-    method: 'POST',
-    headers: { 'content-type': 'application/json', authorization: 'Bearer ' + token },
-    body: JSON.stringify({ json: input === undefined ? {} : input }),
-  });
-  var envelope = await response.json().catch(function () { return {}; });
-  if (!response.ok) {
-    var message = envelope && envelope.json && envelope.json.message ? envelope.json.message : ('HTTP ' + response.status);
-    var error = new Error(message);
-    error.status = response.status;
-    throw error;
+    if (first === V4_LINK_LOCAL_OCTET && second === V4_LINK_LOCAL_SECOND) {
+      return true;
+    }
+    if (first === V4_PRIVATE_B_OCTET && second >= V4_PRIVATE_B_SECOND_FROM && second <= V4_PRIVATE_B_SECOND_TO) {
+      return true;
+    }
+    if (first === V4_PRIVATE_C_OCTET && second === V4_PRIVATE_C_SECOND) {
+      return true;
+    }
+    return first >= V4_MULTICAST_FROM_OCTET;
   }
-  return envelope.json;
-}
-
-// Parses every complete SSE frame out of the buffered text, returning the frames and the unparsed remainder. Comment frames (the door's keepalive opens with one) carry no event name and are dropped.
-function parseSseFrames(buffer) {
-  var frames = [];
-  var rest = buffer;
-  for (;;) {
-    var boundary = rest.indexOf('\\n\\n');
-    if (boundary === -1) { break; }
-    var raw = rest.slice(0, boundary);
-    rest = rest.slice(boundary + 2);
-    var frame = { event: 'message', id: '', data: '' };
-    var lines = raw.split('\\n');
-    for (var i = 0; i < lines.length; i++) {
-      var line = lines[i];
-      if (line === '' || line.charAt(0) === ':') { continue; }
-      var colon = line.indexOf(':');
-      var field = colon === -1 ? line : line.slice(0, colon);
-      var value = colon === -1 ? '' : line.slice(colon + 1);
-      if (value.charAt(0) === ' ') { value = value.slice(1); }
-      if (field === 'event') { frame.event = value; }
-      if (field === 'id') { frame.id = value; }
-      if (field === 'data') { frame.data += (frame.data === '' ? '' : '\\n') + value; }
+  if (version2 === IP_VERSION_6) {
+    const lower = address.toLowerCase();
+    const mapped = /^::ffff:(\d{1,3}(?:\.\d{1,3}){3})$/.exec(lower);
+    if (mapped !== null) {
+      return isPrivateAddress(mapped[1] ?? "");
     }
-    if (frame.data !== '') { frames.push(frame); }
+    if (lower === "::" || lower === "::1") {
+      return true;
+    }
+    const firstGroup = Number.parseInt(/^([0-9a-f]+):/.exec(lower)?.[1] ?? "0", 16);
+    if (Number.isNaN(firstGroup)) {
+      return true;
+    }
+    if (firstGroup >= V6_UNIQUE_LOCAL_FROM && firstGroup <= V6_UNIQUE_LOCAL_TO) {
+      return true;
+    }
+    if (firstGroup >= V6_LINK_LOCAL_FROM && firstGroup <= V6_LINK_LOCAL_TO) {
+      return true;
+    }
+    return firstGroup >= V6_MULTICAST_FROM;
   }
-  return { frames: frames, rest: rest };
+  return true;
 }
-
-// Whether one source-tagged event continues the per-source sequence the tracker holds: the count of events the stream dropped when it does not, zero when it does. The tracker keeps the high-water mark, so a number the door re-sends after a reconnect is a duplicate, not a step back, and never reports a negative gap. The backbone holds no replay, so a gap is reported, never hidden.
-function sequenceGap(tracker, event) {
-  var previous = tracker[event.source];
-  if (event.sequence > (previous === undefined ? 0 : previous)) { tracker[event.source] = event.sequence; }
-  if (previous === undefined || event.sequence <= previous) { return 0; }
-  return event.sequence - previous - 1;
+function isSuccessful3(status) {
+  return status >= HTTP_STATUS.ok && status < SUCCESS_STATUS_MAX_EXCLUSIVE3;
 }
-
-function shortId(id) { return id.length > 14 ? id.slice(0, 8) + '..' + id.slice(-4) : id; }
-
-// A bounded sketch of any payload, the feed's fallback rendering: one JSON line, cut with a marker rather than silently.
-function sketch(value, cap) {
-  var text;
-  try { text = JSON.stringify(value); } catch (e) { text = String(value); }
-  if (text === undefined) { text = 'undefined'; }
-  return text.length > cap ? text.slice(0, cap) + '...' : text;
+function isRedirect(status) {
+  return status === HTTP_MOVED_PERMANENTLY || status === HTTP_FOUND || status === HTTP_SEE_OTHER || status === HTTP_TEMPORARY_REDIRECT || status === HTTP_PERMANENT_REDIRECT;
 }
-
-// The headline text of one Remote Control stream event: the assistant and user payloads that carry a content array of text blocks render as their prose, everything else as its type plus a sketch.
-function rcLine(event) {
-  var envelope = event.envelope;
-  var payload = envelope.payload;
-  var headline = '';
-  if (payload !== undefined && payload !== null && typeof payload === 'object' && Array.isArray(payload.content)) {
-    var parts = [];
-    for (var i = 0; i < payload.content.length; i++) {
-      var block = payload.content[i];
-      if (block !== null && typeof block === 'object' && block.type === 'text' && typeof block.text === 'string') { parts.push(block.text); }
-    }
-    if (parts.length > 0) { headline = parts.join(' '); }
+function readableContentType(contentType) {
+  if (contentType === void 0 || contentType.trim() === "") {
+    return true;
   }
-  if (headline === '') {
-    headline = envelope.event_type;
-    if (payload !== undefined) { headline += '  ' + sketch(payload, 240); }
+  const normalised = contentType.split(";")[0]?.trim().toLowerCase() ?? "";
+  const slash = normalised.indexOf("/");
+  const main2 = slash === -1 ? normalised : normalised.slice(0, slash);
+  const sub = slash === -1 ? "" : normalised.slice(slash + 1);
+  if (main2 === "text") {
+    return true;
   }
-  return new Date().toLocaleTimeString() + '  ' + shortId(event.session) + '  ' + envelope.event_type + '  ' + headline;
+  return /json|xml|javascript|ecmascript|yaml|csv/.test(sub);
 }
-
-function el(tag, className, text) {
-  var node = document.createElement(tag);
-  if (className) { node.className = className; }
-  if (text !== undefined) { node.textContent = text; }
-  return node;
+async function readCapped(chunks) {
+  const collected = [];
+  let total = 0;
+  for await (const chunk of chunks) {
+    total += chunk.byteLength;
+    if (total > RC_WEB_FETCH_MAX_BYTES) {
+      return { tooLarge: true, text: "" };
+    }
+    collected.push(Buffer.from(chunk));
+  }
+  return { tooLarge: false, text: Buffer.concat(collected).toString("utf8") };
 }
-
-var ui = null;
-
-function renderEvent(event, gap) {
-  if (ui === null) { return; }
-  var list = ui.eventList;
-  if (gap > 0) {
-    list.appendChild(el('div', 'event gap', 'dropped events: ' + String(gap) + ' on source ' + event.source + ' (the stream holds no replay)'));
+async function checkTarget(url2, deps) {
+  if (url2.protocol !== "http:" && url2.protocol !== "https:") {
+    return refused("scheme", `the web-fetch proxy dials http and https only, not ${url2.protocol}`);
   }
-  var line;
-  if (event.source === 'rc') {
-    line = rcLine(event.payload);
-  } else {
-    line = new Date().toLocaleTimeString() + '  [' + event.source + ']  ' + sketch(event.payload, 240);
+  if (deps.allowPrivate) {
+    return void 0;
   }
-  list.appendChild(el('div', 'event', line));
-  while (list.childElementCount > 500) { list.removeChild(list.firstChild); }
-  list.scrollTop = list.scrollHeight;
-}
-
-function renderSessions(statuses) {
-  if (ui === null) { return; }
-  var list = ui.sessionList;
-  list.textContent = '';
-  if (statuses.length === 0) {
-    list.appendChild(el('div', 'event dim', 'no Remote Control sessions observed'));
-    return;
+  const hostname3 = url2.hostname.replace(/^\[|\]$/g, "");
+  let addresses;
+  try {
+    addresses = net3.isIP(hostname3) === 0 ? await deps.lookup(hostname3) : [hostname3];
+  } catch {
+    return refused("resolve", `${hostname3} did not resolve`);
   }
-  for (var i = 0; i < statuses.length; i++) {
-    var status = statuses[i];
-    var worker = status.workerState === undefined ? 'worker unknown' : 'worker ' + status.workerState.value;
-    var row = el('div', 'session' + (status.id === ui.selected ? ' selected' : ''));
-    row.appendChild(el('div', null, shortId(status.id)));
-    row.appendChild(el('div', 'dim', worker + (status.pending.length === 0 ? '' : ', ' + String(status.pending.length) + ' pending') + ', seen ' + new Date(status.lastSeenAt).toLocaleTimeString()));
-    row.addEventListener('click', selectSession(status.id));
-    list.appendChild(row);
+  for (const address of addresses) {
+    if (isPrivateAddress(address)) {
+      return refused("private_address", `${hostname3} resolves to ${address}, a private address this web-fetch proxy refuses; set ${RC_WEB_FETCH_ALLOW_PRIVATE_ENV}=1 on the door if serving internal targets is intended`);
+    }
   }
+  return void 0;
 }
-
-function selectSession(id) {
-  return function () {
-    if (ui === null) { return; }
-    ui.selected = ui.selected === id ? null : id;
-    ui.promptTarget.textContent = ui.selected === null ? 'no session selected' : 'to ' + ui.selected;
-    refreshSessions();
-    refreshPending();
-  };
-}
-
-function renderPending(pending) {
-  if (ui === null) { return; }
-  var list = ui.pendingList;
-  list.textContent = '';
-  if (pending.length === 0) {
-    list.appendChild(el('div', 'event dim', 'no control requests awaiting an answer'));
-    return;
+async function fetchThroughWebProxy(url2, deps) {
+  let current;
+  try {
+    current = new URL(url2);
+  } catch {
+    return refused("malformed_url", `${url2} is not a URL this proxy can dial`);
   }
-  for (var i = 0; i < pending.length; i++) {
-    var request = pending[i];
-    var card = el('div', 'card');
-    card.appendChild(el('div', null, request.type + '  ' + (request.summary === '' ? shortId(request.requestId) : request.summary)));
-    card.appendChild(el('div', 'dim', shortId(request.sessionId) + '  ' + shortId(request.requestId) + '  observed ' + new Date(request.observedAt).toLocaleTimeString()));
-    var row = el('div', 'row');
-    var denial = el('input');
-    denial.type = 'text';
-    denial.placeholder = 'denial message (optional)';
-    var approve = el('button', null, 'Approve');
-    var deny = el('button', 'secondary', 'Deny');
-    approve.addEventListener('click', answerRequest(request, true, denial));
-    deny.addEventListener('click', answerRequest(request, false, denial));
-    row.appendChild(denial);
-    row.appendChild(approve);
-    row.appendChild(deny);
-    card.appendChild(row);
-    list.appendChild(card);
+  const controller = new AbortController();
+  const timer = setTimeout(() => {
+    controller.abort();
+  }, deps.deadlineMs);
+  timer.unref();
+  try {
+    let redirects = 0;
+    for (; ; ) {
+      const refusal = await checkTarget(current, deps);
+      if (refusal !== void 0) {
+        return refusal;
+      }
+      let hop;
+      try {
+        hop = await deps.dial(current, controller.signal);
+      } catch (error62) {
+        if (controller.signal.aborted) {
+          return refused("deadline", `the fetch of ${url2} did not settle within its deadline`);
+        }
+        return refused("transport", `the dial of ${current.toString()} failed: ${error62 instanceof Error ? error62.message : "unknown error"}`);
+      }
+      if (isRedirect(hop.status) && hop.location !== void 0) {
+        if (redirects >= RC_WEB_FETCH_MAX_REDIRECTS) {
+          controller.abort();
+          return refused("too_many_redirects", `${url2} followed more than ${String(RC_WEB_FETCH_MAX_REDIRECTS)} redirects without settling`);
+        }
+        let next;
+        try {
+          next = new URL(hop.location, current);
+        } catch {
+          controller.abort();
+          return refused("malformed_url", `a redirect of ${current.toString()} named ${hop.location}, which is not a URL this proxy can dial`);
+        }
+        const drained = await readCapped(hop.chunks);
+        if (drained.tooLarge) {
+          controller.abort();
+          return refused("too_large", `the body of a redirect from ${url2} exceeds the ${String(RC_WEB_FETCH_MAX_BYTES)} byte cap the CLI's proxy client reads`);
+        }
+        redirects += 1;
+        current = next;
+        continue;
+      }
+      if (!isSuccessful3(hop.status)) {
+        controller.abort();
+        return refused("status", `the target answered HTTP ${String(hop.status)} for ${current.toString()}`);
+      }
+      const contentType = hop.contentType ?? "";
+      if (!readableContentType(contentType)) {
+        controller.abort();
+        return refused("content_type", `the target at ${current.toString()} served a ${contentType} answer, which the proxy's text field cannot carry`);
+      }
+      const read = await readCapped(hop.chunks);
+      if (read.tooLarge) {
+        controller.abort();
+        return refused("too_large", `the body of ${current.toString()} exceeds the ${String(RC_WEB_FETCH_MAX_BYTES)} byte cap the CLI's proxy client reads`);
+      }
+      return { kind: "fetched", url: url2, destinationUrl: current.toString(), contentType: hop.contentType, text: read.text };
+    }
+  } finally {
+    clearTimeout(timer);
   }
 }
-
-function answerRequest(request, approve, denialInput) {
-  return function () {
-    var input = { session: request.sessionId, request: request.requestId, approve: approve };
-    if (!approve && denialInput.value !== '') { input.text = denialInput.value; }
-    rpc('rc/answer', input).then(function () {
-      renderEvent({ source: 'page', sequence: 0, payload: { note: (approve ? 'approved' : 'denied') + ' ' + request.requestId } }, 0);
-      refreshPending();
-    }, function (error) { window.alert('answer failed: ' + error.message); });
+function realRcWebFetch(options) {
+  const plainAgent = new ExemptHttpAgent();
+  const tlsAgent = new ExemptTlsAgent();
+  const deps = {
+    dial: async (url2, signal) => await new Promise((resolve, reject) => {
+      const request7 = (url2.protocol === "https:" ? https5 : http6).request(
+        {
+          hostname: url2.hostname,
+          port: url2.port === "" ? void 0 : Number(url2.port),
+          method: "GET",
+          path: `${url2.pathname}${url2.search}`,
+          headers: { accept: "*/*", "accept-encoding": "identity", "user-agent": WEB_FETCH_USER_AGENT },
+          agent: url2.protocol === "https:" ? tlsAgent : plainAgent,
+          signal
+        },
+        (response) => {
+          const location = response.headers.location;
+          resolve({
+            status: response.statusCode ?? 0,
+            location: typeof location === "string" ? location : void 0,
+            contentType: typeof response.headers["content-type"] === "string" ? response.headers["content-type"] : void 0,
+            chunks: response
+          });
+        }
+      );
+      request7.once("error", reject);
+      request7.end();
+    }),
+    lookup: async (hostname3) => (await dns2.promises.lookup(hostname3, { all: true })).map((entry) => entry.address),
+    allowPrivate: options.allowPrivate,
+    deadlineMs: RC_WEB_FETCH_DEADLINE_MS
   };
+  return async (url2) => await fetchThroughWebProxy(url2, deps);
 }
 
-function sendPrompt() {
-  if (ui === null || ui.selected === null) { window.alert('select a session first'); return; }
-  var text = ui.prompt.value;
-  if (text === '') { return; }
-  ui.send.disabled = true;
-  rpc('rc/send', { session: ui.selected, text: text }).then(function (result) {
-    ui.prompt.value = '';
-    renderEvent({ source: 'page', sequence: 0, payload: { note: 'sent, sequence_num ' + result.sequenceNums.join(', ') } }, 0);
-  }, function (error) { window.alert('send failed: ' + error.message); }).then(function () { ui.send.disabled = false; });
-}
-
-function refreshSessions() {
-  rpc('rc/status', {}).then(function (result) { renderSessions(result.statuses); }, authOrReport('rc/status'));
+// 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";
 }
-
-function refreshPending() {
-  rpc('rc/pending', ui !== null && ui.selected !== null ? { session: ui.selected } : {}).then(function (result) { renderPending(result.pending); }, authOrReport('rc/pending'));
+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_SECOND7 = 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_NAME = "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 isRecord4(value2) {
+  return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
-
-// The one error path every call shares: a 401 means this token is not this generation's, so the page says so and asks for it again; anything else is reported in the feed.
-function authOrReport(what) {
-  return function (error) {
-    if (error.status === 401) {
-      handleUnauthorized();
-      return;
-    }
-    renderEvent({ source: 'page', sequence: 0, payload: { note: what + ' failed: ' + error.message } }, 0);
-  };
+function isWebSearchRefusal(value2) {
+  return !Array.isArray(value2);
 }
-
-function handleUnauthorized() {
-  window.sessionStorage.removeItem(TOKEN_KEY);
-  if (feedAbort !== null) { feedAbort.abort(); }
-  streamState('');
-  showTokenForm('this door refused the token: it names a different door generation, paste the current one');
+function nonEmptyString2(record2, field) {
+  const value2 = record2 === void 0 ? void 0 : record2[field];
+  return typeof value2 === "string" && value2 !== "" ? value2 : void 0;
 }
-
-function streamState(text) { if (ui !== null) { ui.streamState.textContent = text; } }
-
-var feedAbort = null;
-
-// Subscribes to the door's backbone and renders what it yields, reconnecting on any drop. The stream holds no replay, so a reconnect starts at the live head and the per-source sequence numbers surface whatever the gap swallowed.
-async function runFeed() {
-  var tracker = {};
-  for (;;) {
-    if (feedAbort !== null) { feedAbort.abort(); }
-    feedAbort = new AbortController();
-    var filter = document.getElementById('source-filter').value;
-    var input = filter === '' ? {} : { sources: [filter] };
-    try {
-      streamState('stream: connecting');
-      var response = await fetch(apiBase() + '/events/subscribe', {
-        method: 'POST',
-        headers: { 'content-type': 'application/json', authorization: 'Bearer ' + token },
-        body: JSON.stringify({ json: input }),
-        signal: feedAbort.signal,
-      });
-      if (response.status === 401) { handleUnauthorized(); return; }
-      if (!response.ok || response.body === null) { throw new Error('HTTP ' + String(response.status)); }
-      streamState('stream: live');
-      var reader = response.body.getReader();
-      var decoder = new TextDecoder();
-      var buffer = '';
-      for (;;) {
-        var chunk = await reader.read();
-        if (chunk.done) { break; }
-        buffer += decoder.decode(chunk.value, { stream: true });
-        var parsed = parseSseFrames(buffer);
-        buffer = parsed.rest;
-        for (var i = 0; i < parsed.frames.length; i++) {
-          var frame = parsed.frames[i];
-          if (frame.event !== 'message') { continue; }
-          var event;
-          try { event = JSON.parse(frame.data).json; } catch (e) { continue; }
-          if (event === undefined || event.source === undefined) { continue; }
-          renderEvent(event, sequenceGap(tracker, event));
-        }
-      }
-    } catch (error) {
-      if (feedAbort !== null && feedAbort.signal.aborted) { return; }
-    }
-    streamState('stream: dropped, reconnecting');
-    await new Promise(function (resolve) { window.setTimeout(resolve, 1000); });
+function numberOf(record2, field) {
+  const value2 = record2 === void 0 ? void 0 : record2[field];
+  if (typeof value2 === "number" && Number.isFinite(value2)) {
+    return value2;
+  }
+  if (typeof value2 === "string" && /^[0-9]+$/.test(value2)) {
+    return Number(value2);
   }
+  return void 0;
 }
-
-function showTokenForm(message) {
-  if (feedAbort !== null) { feedAbort.abort(); }
-  if (ui !== null) { ui.main.classList.add('hidden'); }
-  var form = document.getElementById('token-form');
-  form.classList.remove('hidden');
-  document.getElementById('token-error').textContent = message === undefined ? '' : message;
-  document.getElementById('token-input').focus();
-}
-
-function startPage(heldToken) {
-  token = heldToken;
-  ui = {
-    main: document.getElementById('main'),
-    eventList: document.getElementById('event-list'),
-    sessionList: document.getElementById('session-list'),
-    pendingList: document.getElementById('pending-list'),
-    prompt: document.getElementById('prompt'),
-    promptTarget: document.getElementById('prompt-target'),
-    send: document.getElementById('send'),
-    streamState: document.getElementById('stream-state'),
-    selected: null,
-  };
-  document.getElementById('token-form').classList.add('hidden');
-  ui.main.classList.remove('hidden');
-  document.getElementById('refresh').addEventListener('click', function () { refreshSessions(); refreshPending(); });
-  document.getElementById('send').addEventListener('click', sendPrompt);
-  document.getElementById('source-filter').addEventListener('change', function () { runFeed(); });
-  ui.prompt.addEventListener('keydown', function (event) {
-    if (event.key === 'Enter' && (event.metaKey || event.ctrlKey)) { sendPrompt(); }
-  });
-  refreshSessions();
-  refreshPending();
-  window.setInterval(function () { refreshSessions(); refreshPending(); }, 4000);
-  runFeed();
-  document.getElementById('door-state').textContent = 'connected';
-}
-
-function boot() {
-  var held = null;
-  var query = new URLSearchParams(window.location.search);
-  var fromQuery = query.get('token');
-  if (fromQuery !== null && fromQuery !== '') {
-    window.sessionStorage.setItem(TOKEN_KEY, fromQuery);
-    // The token leaves the address bar the moment the page holds it, so a refresh or a shared screen shows the clean URL; sessionStorage keeps the tab working.
-    window.history.replaceState(null, '', window.location.pathname);
-    held = fromQuery;
-  } else {
-    held = window.sessionStorage.getItem(TOKEN_KEY);
+function stringArray(record2, field) {
+  const value2 = record2 === void 0 ? void 0 : record2[field];
+  if (!Array.isArray(value2)) {
+    return void 0;
   }
-  document.getElementById('token-save').addEventListener('click', function () {
-    var value = document.getElementById('token-input').value.trim();
-    if (value === '') { return; }
-    window.sessionStorage.setItem(TOKEN_KEY, value);
-    startPage(value);
-  });
-  document.getElementById('token-input').addEventListener('keydown', function (event) {
-    if (event.key === 'Enter') { document.getElementById('token-save').click(); }
-  });
-  if (held !== null && held !== '') { startPage(held); }
-}
-
-if (typeof document !== 'undefined' && document.getElementById('event-list') !== null) {
-  window.addEventListener('DOMContentLoaded', boot);
+  const members2 = [];
+  for (const member of value2) {
+    if (typeof member !== "string") {
+      return void 0;
+    }
+    members2.push(member);
+  }
+  return members2;
 }
-`;
-var RC_CLIENT_PAGE_HTML = `<!doctype html>
-<html lang="en">
-<head>
-<meta charset="utf-8">
-<meta name="viewport" content="width=device-width, initial-scale=1">
-<title>agent-shim Remote Control</title>
-<style>
-  :root { color-scheme: dark; }
-  * { box-sizing: border-box; }
-  body { margin: 0; background: #101418; color: #d7dde3; font: 14px/1.45 ui-monospace, Menlo, Consolas, monospace; }
-  header { display: flex; gap: 12px; align-items: baseline; padding: 10px 16px; background: #171d24; border-bottom: 1px solid #2a333d; }
-  header h1 { font-size: 15px; margin: 0; font-weight: 600; }
-  header .state { color: #8b98a5; }
-  main { display: flex; gap: 1px; background: #2a333d; min-height: calc(100vh - 39px); }
-  section { background: #101418; padding: 12px 16px; overflow-y: auto; }
-  #sessions { flex: 0 0 320px; border-right: 1px solid #2a333d; }
-  #right { flex: 1; display: flex; flex-direction: column; min-width: 0; }
-  #feed { flex: 1; }
-  #controls { border-top: 1px solid #2a333d; }
-  h2 { font-size: 12px; text-transform: uppercase; letter-spacing: 0.08em; color: #8b98a5; margin: 8px 0 8px; font-weight: 600; }
-  .session { padding: 6px 8px; border: 1px solid transparent; border-radius: 4px; cursor: pointer; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
-  .session:hover { background: #171d24; }
-  .session.selected { border-color: #3d6ea5; background: #17222e; }
-  .session .dim { color: #8b98a5; }
-  .event { padding: 2px 0; white-space: pre-wrap; word-break: break-word; }
-  .event .dim { color: #8b98a5; }
-  .event.gap { color: #d29922; }
-  .event.error { color: #e5534b; }
-  textarea, input[type=text], select { background: #171d24; color: #d7dde3; border: 1px solid #2a333d; border-radius: 4px; padding: 6px 8px; font: inherit; width: 100%; }
-  textarea { resize: vertical; min-height: 44px; }
-  button { background: #1f4a7a; color: #d7dde3; border: 1px solid #3d6ea5; border-radius: 4px; padding: 5px 12px; font: inherit; cursor: pointer; }
-  button.secondary { background: #2a333d; border-color: #3a444f; }
-  button:disabled { opacity: 0.5; cursor: default; }
-  .row { display: flex; gap: 8px; margin: 6px 0; align-items: center; }
-  .card { border: 1px solid #3d6ea5; border-radius: 4px; padding: 8px; margin: 6px 0; background: #17222e; }
-  .card .dim { color: #8b98a5; }
-  #token-form { max-width: 480px; margin: 48px auto; }
-  #token-form p { color: #8b98a5; }
-  .hidden { display: none !important; }
-</style>
-</head>
-<body data-agent-shim-rc-client>
-<header>
-  <h1>agent-shim Remote Control</h1>
-  <span class="state" id="door-state">connecting</span>
-  <span class="state" id="stream-state"></span>
-</header>
-<div id="token-form">
-  <h2>This door's control token</h2>
-  <p>The page is served behind the door's per-generation control token. Paste this door generation's token (the owner-only value the door writes beside its state) to use the page; it stays in this tab only.</p>
-  <div class="row"><input type="text" id="token-input" placeholder="control token" autocomplete="off"><button id="token-save">Use</button></div>
-  <p id="token-error" class="event error"></p>
-</div>
-<main class="hidden" id="main">
-  <section id="sessions">
-    <h2>Sessions <button class="secondary" id="refresh">Refresh</button></h2>
-    <div id="session-list"></div>
-  </section>
-  <section id="right">
-    <div id="feed">
-      <h2>Feed <select id="source-filter"><option value="">all sources</option><option value="rc">Remote Control only</option></select></h2>
-      <div id="event-list"></div>
-    </div>
-    <div id="controls">
-      <h2>Pending approvals</h2>
-      <div id="pending-list"></div>
-      <h2>Send a prompt</h2>
-      <div class="row"><textarea id="prompt" placeholder="Prompt for the selected session"></textarea></div>
-      <div class="row"><span class="dim" id="prompt-target">no session selected</span><span style="flex:1"></span><button id="send">Send</button></div>
-    </div>
-  </section>
-</main>
-<script>
-${RC_CLIENT_PAGE_SCRIPT}
-</script>
-</body>
-</html>
-`;
-function pageTokenOf(request7, url2) {
-  const presented = request7.headers.authorization;
-  const bearerPrefix = "bearer ".length;
-  const header = typeof presented === "string" && presented.slice(0, bearerPrefix).toLowerCase() === "bearer " ? presented.slice(bearerPrefix) : void 0;
-  const query = url2.searchParams.get("token") ?? void 0;
-  return header ?? query;
+function singleHeader2(headers, name) {
+  const value2 = headers[name];
+  return typeof value2 === "string" ? value2 : void 0;
 }
-function serveRcClientPage(expectedToken, request7, response) {
-  const url2 = new URL(request7.url ?? "/", "https://door.invalid");
-  if (url2.pathname !== RC_CLIENT_PATH && url2.pathname !== `${RC_CLIENT_PATH}/`) {
-    response.writeHead(HTTP_STATUS.notFound, { "Content-Type": "text/plain" });
-    response.end("no such page under the door's client prefix");
-    return;
+function bearerOf(headers) {
+  const presented = singleHeader2(headers, "authorization");
+  if (presented === void 0) {
+    return void 0;
   }
-  if (request7.method !== "GET" && request7.method !== "HEAD") {
-    response.writeHead(HTTP_STATUS.methodNotAllowed, { Allow: "GET, HEAD", "Content-Type": "text/plain" });
-    response.end("the door's web client page is read-only");
-    return;
+  return presented.slice(0, "bearer ".length).toLowerCase() === "bearer " ? presented.slice("bearer ".length) : void 0;
+}
+function presentationRefusal(headers) {
+  const presented = singleHeader2(headers, "authorization");
+  if (presented === void 0) {
+    return "absent";
   }
-  const token = pageTokenOf(request7, url2);
-  if (token === void 0 || !isLiveCapability(token, [expectedToken])) {
-    response.writeHead(HTTP_STATUS.unauthorized, { "Content-Type": "application/json" });
-    response.end(JSON.stringify({ error: "the door's web client demands this generation's control token, as a Bearer credential or the token query parameter" }));
-    return;
+  if (presented.slice(0, "bearer ".length).toLowerCase() !== "bearer ") {
+    return "not-a-bearer";
   }
-  response.writeHead(HTTP_STATUS.ok, {
-    "Content-Type": "text/html; charset=utf-8",
-    "Cache-Control": "no-store",
-    "Referrer-Policy": "no-referrer",
-    "Content-Security-Policy": "default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; connect-src 'self'"
+  const bearer = presented.slice("bearer ".length);
+  return bearer.slice(0, "bearer ".length).toLowerCase() === "bearer " ? "doubled-scheme-word" : "unrecognised";
+}
+async function readBody3(request7, capBytes) {
+  return await new Promise((resolve, reject) => {
+    const chunks = [];
+    let total = 0;
+    request7.on("data", (chunk) => {
+      total += chunk.length;
+      if (total > capBytes) {
+        request7.destroy();
+        reject(new Error("body too large"));
+        return;
+      }
+      chunks.push(chunk);
+    });
+    request7.on("end", () => {
+      resolve(Buffer.concat(chunks).toString("utf8"));
+    });
+    request7.on("error", () => {
+      reject(new Error("the request body ended early"));
+    });
   });
-  response.end(request7.method === "HEAD" ? void 0 : RC_CLIENT_PAGE_HTML);
 }
-function createRcClientPage(expectedToken) {
+function parseJsonObject2(body) {
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return void 0;
+  }
+  return isRecord4(parsed) ? parsed : void 0;
+}
+function mintWorkerJwt(randomToken, issuedAt) {
+  const encode3 = (value2) => Buffer.from(JSON.stringify(value2), "utf8").toString("base64url");
+  const header = encode3({ alg: "HS256", typ: "JWT" });
+  const payload = encode3({ exp: Math.floor((issuedAt + RC_SELF_HOST_WORKER_JWT_TTL_SECONDS * MS_PER_SECOND7) / MS_PER_SECOND7), iat: Math.floor(issuedAt / MS_PER_SECOND7) });
+  return `${header}.${payload}.${Buffer.from(randomToken(), "utf8").toString("base64url")}`;
+}
+function growthBookFeatures() {
   return {
-    pathPrefix: RC_CLIENT_PATH,
-    handle: async (request7, response) => {
-      serveRcClientPage(expectedToken, request7, response);
-      await Promise.resolve();
-      return { matched: true };
-    }
+    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" } }
   };
 }
-
-// src/frontdoor/rcWebFetch.ts
-var dns2 = __toESM(require("node:dns"), 1);
-var http6 = __toESM(require("node:http"), 1);
-var https5 = __toESM(require("node:https"), 1);
-var net3 = __toESM(require("node:net"), 1);
-var RC_WEB_FETCH_MAX_BYTES = 12582912;
-var RC_WEB_FETCH_DEADLINE_MS = 4e4;
-var RC_WEB_FETCH_MAX_REDIRECTS = 20;
-var RC_WEB_FETCH_ALLOW_PRIVATE_ENV = "AGENT_SHIM_FRONTDOOR_RC_SELF_HOST_WEB_FETCH_ALLOW_PRIVATE";
-function rcWebFetchAllowsPrivateFromEnv(env) {
-  return env[RC_WEB_FETCH_ALLOW_PRIVATE_ENV] === "1";
-}
-var WEB_FETCH_USER_AGENT = "agent-shim-frontdoor";
-var ERROR_PREFIX = "web_fetch_";
-var V4_THIS_NETWORK_OCTET = 0;
-var V4_PRIVATE_A_OCTET = 10;
-var V4_LOOPBACK_OCTET = 127;
-var V4_CGNAT_OCTET = 100;
-var V4_CGNAT_SECOND_FROM = 64;
-var V4_CGNAT_SECOND_TO = 127;
-var V4_LINK_LOCAL_OCTET = 169;
-var V4_LINK_LOCAL_SECOND = 254;
-var V4_PRIVATE_B_OCTET = 172;
-var V4_PRIVATE_B_SECOND_FROM = 16;
-var V4_PRIVATE_B_SECOND_TO = 31;
-var V4_PRIVATE_C_OCTET = 192;
-var V4_PRIVATE_C_SECOND = 168;
-var V4_MULTICAST_FROM_OCTET = 224;
-var V6_UNIQUE_LOCAL_FROM = 64512;
-var V6_UNIQUE_LOCAL_TO = 65023;
-var V6_LINK_LOCAL_FROM = 65152;
-var V6_LINK_LOCAL_TO = 65215;
-var V6_MULTICAST_FROM = 65280;
-var IP_VERSION_4 = 4;
-var IP_VERSION_6 = 6;
-var HTTP_MOVED_PERMANENTLY = 301;
-var HTTP_FOUND = 302;
-var HTTP_SEE_OTHER = 303;
-var HTTP_TEMPORARY_REDIRECT = 307;
-var HTTP_PERMANENT_REDIRECT = 308;
-var SUCCESS_STATUS_MAX_EXCLUSIVE3 = 300;
-function refused(errorType, errorMessage2) {
-  return { kind: "refused", errorType: `${ERROR_PREFIX}${errorType}`, errorMessage: errorMessage2 };
-}
-function isPrivateAddress(address) {
-  const version2 = net3.isIP(address);
-  if (version2 === IP_VERSION_4) {
-    const octets = address.split(".").map((part) => Number(part));
-    const first = octets[0] ?? -1;
-    const second = octets[1] ?? -1;
-    if (first === V4_THIS_NETWORK_OCTET || first === V4_PRIVATE_A_OCTET || first === V4_LOOPBACK_OCTET) {
-      return true;
+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 uuid3 = dropped === void 0 ? void 0 : nonEmptyString2(dropped.payload, "uuid");
+        if (uuid3 !== void 0) {
+          session.seenPayloadUuids.delete(uuid3);
+        }
+      }
+      if (session.workerStreams.size === 0 && session.clientStreams.size === 0 && now - session.lastTrafficAt > RC_SELF_HOST_RETENTION_MS) {
+        sessions.delete(session.id);
+      }
     }
-    if (first === V4_CGNAT_OCTET && second >= V4_CGNAT_SECOND_FROM && second <= V4_CGNAT_SECOND_TO) {
-      return true;
+  };
+  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");
+      }
     }
-    if (first === V4_LINK_LOCAL_OCTET && second === V4_LINK_LOCAL_SECOND) {
-      return true;
+  }, 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;
     }
-    if (first === V4_PRIVATE_B_OCTET && second >= V4_PRIVATE_B_SECOND_FROM && second <= V4_PRIVATE_B_SECOND_TO) {
-      return true;
+    for (const minted of session.workerJwts) {
+      if (isLiveCapability(presented, [minted])) {
+        return true;
+      }
     }
-    if (first === V4_PRIVATE_C_OCTET && second === V4_PRIVATE_C_SECOND) {
-      return true;
+    return false;
+  };
+  const credentialRefusal = (headers) => presentsCredential(headers) ? void 0 : presentationRefusal(headers);
+  const workerRefusal = (headers, session) => presentsWorkerJwt(headers, session) ? void 0 : presentationRefusal(headers);
+  const workerOrCredentialRefusal = (headers, session) => presentsWorkerJwt(headers, session) || presentsCredential(headers) ? void 0 : presentationRefusal(headers);
+  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_NAME}
+id: ${String(event.sequenceNum)}
+data: ${JSON.stringify(envelope)}
+
+`;
+  };
+  const holdStream = async (session, which, wantsReplay, request7, response) => {
+    const url2 = new URL(request7.url, "http://127.0.0.1");
+    const cursor3 = numberOf({ value: url2.searchParams.get("from_sequence_num") }, "value") ?? numberOf({ value: singleHeader2(request7.headers, "last-event-id") }, "value");
+    const replay = cursor3 === void 0 ? [] : session.events.filter((event) => wantsReplay(event) && event.sequenceNum > cursor3);
+    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));
     }
-    return first >= V4_MULTICAST_FROM_OCTET;
-  }
-  if (version2 === IP_VERSION_6) {
-    const lower = address.toLowerCase();
-    const mapped = /^::ffff:(\d{1,3}(?:\.\d{1,3}){3})$/.exec(lower);
-    if (mapped !== null) {
-      return isPrivateAddress(mapped[1] ?? "");
+    await new Promise((resolve) => {
+      request7.signal.addEventListener("abort", () => {
+        resolve(void 0);
+      }, { once: true });
+    });
+    sink.retire();
+    response.end();
+  };
+  const publish = (session, source, payload) => {
+    const uuid3 = nonEmptyString2(payload, "uuid");
+    const duplicate = uuid3 !== void 0 && session.seenPayloadUuids.has(uuid3);
+    session.sequenceNum += 1;
+    const event = {
+      sequenceNum: session.sequenceNum,
+      eventId: uuid3 ?? 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 (uuid3 !== void 0) {
+      session.seenPayloadUuids.add(uuid3);
     }
-    if (lower === "::" || lower === "::1") {
-      return true;
+    session.lastTrafficAt = event.storedAt;
+    const frame = frameOf(event);
+    if (event.toWorker) {
+      for (const sink of [...session.workerStreams]) {
+        sink.write(frame);
+      }
     }
-    const firstGroup = Number.parseInt(/^([0-9a-f]+):/.exec(lower)?.[1] ?? "0", 16);
-    if (Number.isNaN(firstGroup)) {
-      return true;
+    for (const sink of [...session.clientStreams]) {
+      sink.write(frame);
     }
-    if (firstGroup >= V6_UNIQUE_LOCAL_FROM && firstGroup <= V6_UNIQUE_LOCAL_TO) {
-      return true;
+    return { sequenceNum: event.sequenceNum, eventId: event.eventId, duplicate };
+  };
+  const answerJson2 = async (response, status, body, extraHeaders = {}) => {
+    const text2 = JSON.stringify(body);
+    response.start(status, { "content-type": "application/json", "content-length": String(Buffer.byteLength(text2, "utf8")), ...extraHeaders });
+    await response.write(text2);
+    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 refusalMessages = {
+    absent: "the self-hosted Remote Control surface authenticates by the Authorization header, and this call carried none",
+    "not-a-bearer": "the self-hosted Remote Control surface reads a Bearer authorization, and this call's Authorization header did not carry the Bearer scheme word",
+    "doubled-scheme-word": "the self-hosted Remote Control surface reads one Bearer scheme word, and this call's Authorization header carried it twice: a persisted session record holds the whole header value with the scheme word included, so prefixing Bearer onto it presents a different credential",
+    unrecognised: "the self-hosted Remote Control surface did not recognise the presented credential"
+  };
+  const unauthorized = async (response, refusal) => {
+    await answerJson2(response, HTTP_STATUS.unauthorized, { type: "error", error: { type: "authentication_error", message: refusalMessages[refusal] } });
+  };
+  const serveSessionPath = async (session, tail, request7, response) => {
+    const method = request7.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;
     }
-    if (firstGroup >= V6_LINK_LOCAL_FROM && firstGroup <= V6_LINK_LOCAL_TO) {
-      return true;
+    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;
     }
-    return firstGroup >= V6_MULTICAST_FROM;
-  }
-  return true;
-}
-function isSuccessful3(status) {
-  return status >= HTTP_STATUS.ok && status < SUCCESS_STATUS_MAX_EXCLUSIVE3;
-}
-function isRedirect(status) {
-  return status === HTTP_MOVED_PERMANENTLY || status === HTTP_FOUND || status === HTTP_SEE_OTHER || status === HTTP_TEMPORARY_REDIRECT || status === HTTP_PERMANENT_REDIRECT;
-}
-function readableContentType(contentType) {
-  if (contentType === void 0 || contentType.trim() === "") {
-    return true;
-  }
-  const normalised = contentType.split(";")[0]?.trim().toLowerCase() ?? "";
-  const slash = normalised.indexOf("/");
-  const main2 = slash === -1 ? normalised : normalised.slice(0, slash);
-  const sub = slash === -1 ? "" : normalised.slice(slash + 1);
-  if (main2 === "text") {
-    return true;
-  }
-  return /json|xml|javascript|ecmascript|yaml|csv/.test(sub);
-}
-async function readCapped(chunks) {
-  const collected = [];
-  let total = 0;
-  for await (const chunk of chunks) {
-    total += chunk.byteLength;
-    if (total > RC_WEB_FETCH_MAX_BYTES) {
-      return { tooLarge: true, text: "" };
+    if (tail === "bridge" && method === "POST") {
+      const refusal = credentialRefusal(request7.headers);
+      if (refusal !== void 0) {
+        await unauthorized(response, refusal);
+        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;
     }
-    collected.push(Buffer.from(chunk));
-  }
-  return { tooLarge: false, text: Buffer.concat(collected).toString("utf8") };
-}
-async function checkTarget(url2, deps) {
-  if (url2.protocol !== "http:" && url2.protocol !== "https:") {
-    return refused("scheme", `the web-fetch proxy dials http and https only, not ${url2.protocol}`);
-  }
-  if (deps.allowPrivate) {
-    return void 0;
-  }
-  const hostname3 = url2.hostname.replace(/^\[|\]$/g, "");
-  let addresses;
-  try {
-    addresses = net3.isIP(hostname3) === 0 ? await deps.lookup(hostname3) : [hostname3];
-  } catch {
-    return refused("resolve", `${hostname3} did not resolve`);
-  }
-  for (const address of addresses) {
-    if (isPrivateAddress(address)) {
-      return refused("private_address", `${hostname3} resolves to ${address}, a private address this web-fetch proxy refuses; set ${RC_WEB_FETCH_ALLOW_PRIVATE_ENV}=1 on the door if serving internal targets is intended`);
+    if (tail === "archive" && method === "POST") {
+      const refusal = credentialRefusal(request7.headers);
+      if (refusal !== void 0) {
+        await unauthorized(response, refusal);
+        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;
     }
-  }
-  return void 0;
-}
-async function fetchThroughWebProxy(url2, deps) {
-  let current;
-  try {
-    current = new URL(url2);
-  } catch {
-    return refused("malformed_url", `${url2} is not a URL this proxy can dial`);
-  }
-  const controller = new AbortController();
-  const timer = setTimeout(() => {
-    controller.abort();
-  }, deps.deadlineMs);
-  timer.unref();
-  try {
-    let redirects = 0;
-    for (; ; ) {
-      const refusal = await checkTarget(current, deps);
+    if (tail === "worker" || tail.startsWith("worker/")) {
+      const workerTail = tail === "worker" ? "" : tail.slice("worker/".length);
+      const webProxy = workerTail === "web-fetch" || workerTail === "web-search";
+      const refusal = webProxy ? workerOrCredentialRefusal(request7.headers, session) : workerRefusal(request7.headers, session);
       if (refusal !== void 0) {
-        return refusal;
+        await unauthorized(response, refusal);
+        return;
       }
-      let hop;
-      try {
-        hop = await deps.dial(current, controller.signal);
-      } catch (error62) {
-        if (controller.signal.aborted) {
-          return refused("deadline", `the fetch of ${url2} did not settle within its deadline`);
+      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 readBody3(request7.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;
         }
-        return refused("transport", `the dial of ${current.toString()} failed: ${error62 instanceof Error ? error62.message : "unknown error"}`);
+        const status = nonEmptyString2(body, "worker_status");
+        if (status !== void 0) {
+          session.workerStatus = status;
+        }
+        if (isRecord4(body?.external_metadata)) {
+          session.externalMetadata = body.external_metadata;
+        }
+        await answerJson2(response, HTTP_STATUS.ok, {});
+        return;
       }
-      if (isRedirect(hop.status) && hop.location !== void 0) {
-        if (redirects >= RC_WEB_FETCH_MAX_REDIRECTS) {
-          controller.abort();
-          return refused("too_many_redirects", `${url2} followed more than ${String(RC_WEB_FETCH_MAX_REDIRECTS)} redirects without settling`);
+      if (workerTail === "register" && method === "POST") {
+        await readBody3(request7.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 readBody3(request7.body, CONTROL_BODY_CAP_BYTES);
+        await answerJson2(response, HTTP_STATUS.ok, {});
+        return;
+      }
+      if (workerTail === "events" && method === "POST") {
+        const body = parseJsonObject2(await readBody3(request7.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;
         }
-        let next;
-        try {
-          next = new URL(hop.location, current);
-        } catch {
-          controller.abort();
-          return refused("malformed_url", `a redirect of ${current.toString()} named ${hop.location}, which is not a URL this proxy can dial`);
+        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 drained = await readCapped(hop.chunks);
-        if (drained.tooLarge) {
-          controller.abort();
-          return refused("too_large", `the body of a redirect from ${url2} exceeds the ${String(RC_WEB_FETCH_MAX_BYTES)} byte cap the CLI's proxy client reads`);
+        const results = [];
+        for (const event of events) {
+          if (!isRecord4(event) || !isRecord4(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) });
         }
-        redirects += 1;
-        current = next;
-        continue;
+        sweep();
+        await answerJson2(response, HTTP_STATUS.ok, { results });
+        return;
       }
-      if (!isSuccessful3(hop.status)) {
-        controller.abort();
-        return refused("status", `the target answered HTTP ${String(hop.status)} for ${current.toString()}`);
+      if (workerTail === "events/stream" && method === "GET") {
+        await holdStream(session, "workerStreams", (event) => event.toWorker, request7, response);
+        return;
       }
-      const contentType = hop.contentType ?? "";
-      if (!readableContentType(contentType)) {
-        controller.abort();
-        return refused("content_type", `the target at ${current.toString()} served a ${contentType} answer, which the proxy's text field cannot carry`);
+      if (workerTail === "events/delivery" && method === "POST") {
+        await readBody3(request7.body, CONTROL_BODY_CAP_BYTES);
+        await answerJson2(response, HTTP_STATUS.ok, {});
+        return;
       }
-      const read = await readCapped(hop.chunks);
-      if (read.tooLarge) {
-        controller.abort();
-        return refused("too_large", `the body of ${current.toString()} exceeds the ${String(RC_WEB_FETCH_MAX_BYTES)} byte cap the CLI's proxy client reads`);
+      if (workerTail === "internal-events" && method === "POST") {
+        const body = parseJsonObject2(await readBody3(request7.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 (isRecord4(event)) {
+            session.internalEvents.push({ cursor: deps.newUuid(), body: event });
+          }
+        }
+        await answerJson2(response, HTTP_STATUS.ok, {});
+        return;
       }
-      return { kind: "fetched", url: url2, destinationUrl: current.toString(), contentType: hop.contentType, text: read.text };
-    }
-  } finally {
-    clearTimeout(timer);
-  }
-}
-function realRcWebFetch(options) {
-  const plainAgent = new ExemptHttpAgent();
-  const tlsAgent = new ExemptTlsAgent();
-  const deps = {
-    dial: async (url2, signal) => await new Promise((resolve, reject) => {
-      const request7 = (url2.protocol === "https:" ? https5 : http6).request(
-        {
-          hostname: url2.hostname,
-          port: url2.port === "" ? void 0 : Number(url2.port),
-          method: "GET",
-          path: `${url2.pathname}${url2.search}`,
-          headers: { accept: "*/*", "accept-encoding": "identity", "user-agent": WEB_FETCH_USER_AGENT },
-          agent: url2.protocol === "https:" ? tlsAgent : plainAgent,
-          signal
-        },
-        (response) => {
-          const location = response.headers.location;
-          resolve({
-            status: response.statusCode ?? 0,
-            location: typeof location === "string" ? location : void 0,
-            contentType: typeof response.headers["content-type"] === "string" ? response.headers["content-type"] : void 0,
-            chunks: response
-          });
+      if (workerTail === "internal-events" && method === "GET") {
+        const url2 = new URL(request7.url, "http://127.0.0.1");
+        const cursor3 = url2.searchParams.get("cursor");
+        const from = cursor3 === null ? 0 : session.internalEvents.findIndex((event) => event.cursor === cursor3) + 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 readBody3(request7.body, CONTROL_BODY_CAP_BYTES);
+        await answerJson2(response, HTTP_STATUS.ok, {});
+        return;
+      }
+      if (workerTail === "web-fetch" && method === "POST") {
+        const body = parseJsonObject2(await readBody3(request7.body, CONTROL_BODY_CAP_BYTES));
+        const target = nonEmptyString2(body, "url");
+        if (target === void 0) {
+          await answerJson2(response, HTTP_STATUS.badRequest, { type: "error", error: { type: "invalid_request_error", message: "a worker web-fetch carries one url" } });
+          return;
         }
-      );
-      request7.once("error", reject);
-      request7.end();
-    }),
-    lookup: async (hostname3) => (await dns2.promises.lookup(hostname3, { all: true })).map((entry) => entry.address),
-    allowPrivate: options.allowPrivate,
-    deadlineMs: RC_WEB_FETCH_DEADLINE_MS
-  };
-  return async (url2) => await fetchThroughWebProxy(url2, deps);
-}
-
-// 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_SECOND7 = 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_NAME = "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(value2) {
-  return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
-}
-function isWebSearchRefusal(value2) {
-  return !Array.isArray(value2);
-}
-function nonEmptyString2(record2, field) {
-  const value2 = record2 === void 0 ? void 0 : record2[field];
-  return typeof value2 === "string" && value2 !== "" ? value2 : void 0;
-}
-function numberOf(record2, field) {
-  const value2 = record2 === void 0 ? void 0 : record2[field];
-  if (typeof value2 === "number" && Number.isFinite(value2)) {
-    return value2;
-  }
-  if (typeof value2 === "string" && /^[0-9]+$/.test(value2)) {
-    return Number(value2);
-  }
-  return void 0;
-}
-function stringArray(record2, field) {
-  const value2 = record2 === void 0 ? void 0 : record2[field];
-  if (!Array.isArray(value2)) {
-    return void 0;
-  }
-  const members2 = [];
-  for (const member of value2) {
-    if (typeof member !== "string") {
-      return void 0;
-    }
-    members2.push(member);
-  }
-  return members2;
-}
-function singleHeader2(headers, name) {
-  const value2 = headers[name];
-  return typeof value2 === "string" ? value2 : 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;
-}
-function presentationRefusal(headers) {
-  const presented = singleHeader2(headers, "authorization");
-  if (presented === void 0) {
-    return "absent";
-  }
-  if (presented.slice(0, "bearer ".length).toLowerCase() !== "bearer ") {
-    return "not-a-bearer";
-  }
-  const bearer = presented.slice("bearer ".length);
-  return bearer.slice(0, "bearer ".length).toLowerCase() === "bearer " ? "doubled-scheme-word" : "unrecognised";
-}
-async function readBody3(request7, capBytes) {
-  return await new Promise((resolve, reject) => {
-    const chunks = [];
-    let total = 0;
-    request7.on("data", (chunk) => {
-      total += chunk.length;
-      if (total > capBytes) {
-        request7.destroy();
-        reject(new Error("body too large"));
+        const outcome = await deps.webFetch(target);
+        if (outcome.kind === "fetched") {
+          const answer = { url: target, destination_url: outcome.destinationUrl, text: outcome.text, ...outcome.contentType === void 0 ? {} : { content_type: outcome.contentType } };
+          if (Buffer.byteLength(JSON.stringify(answer), "utf8") > RC_WEB_FETCH_MAX_BYTES) {
+            deps.log?.(`rc selfhost ${session.id}: worker web-fetch of ${target} escaped past the reader cap when framed`);
+            await answerJson2(response, HTTP_STATUS.ok, { error: { error_type: "web_fetch_too_large", error_message: `the answer for ${target} exceeds the ${String(RC_WEB_FETCH_MAX_BYTES)} byte cap the CLI's proxy client reads` } });
+            return;
+          }
+          deps.log?.(`rc selfhost ${session.id}: worker web-fetch served ${target} as ${outcome.destinationUrl}`);
+          await answerJson2(response, HTTP_STATUS.ok, answer);
+          return;
+        }
+        deps.log?.(`rc selfhost ${session.id}: worker web-fetch of ${target} refused: ${outcome.errorType}`);
+        await answerJson2(response, HTTP_STATUS.ok, { error: { error_type: outcome.errorType, error_message: outcome.errorMessage } });
         return;
       }
-      chunks.push(chunk);
-    });
-    request7.on("end", () => {
-      resolve(Buffer.concat(chunks).toString("utf8"));
-    });
-    request7.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 encode3 = (value2) => Buffer.from(JSON.stringify(value2), "utf8").toString("base64url");
-  const header = encode3({ alg: "HS256", typ: "JWT" });
-  const payload = encode3({ exp: Math.floor((issuedAt + RC_SELF_HOST_WORKER_JWT_TTL_SECONDS * MS_PER_SECOND7) / MS_PER_SECOND7), iat: Math.floor(issuedAt / MS_PER_SECOND7) });
-  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 uuid3 = dropped === void 0 ? void 0 : nonEmptyString2(dropped.payload, "uuid");
-        if (uuid3 !== void 0) {
-          session.seenPayloadUuids.delete(uuid3);
+      if (workerTail === "web-search" && method === "POST") {
+        const body = parseJsonObject2(await readBody3(request7.body, CONTROL_BODY_CAP_BYTES));
+        const query = nonEmptyString2(body, "query");
+        if (query === void 0) {
+          await answerJson2(response, HTTP_STATUS.badRequest, { type: "error", error: { type: "invalid_request_error", message: "a worker web-search carries one query" } });
+          return;
         }
+        const allowedDomains = stringArray(body, "allowed_domains");
+        const blockedDomains = stringArray(body, "blocked_domains");
+        if (body?.allowed_domains !== void 0 && allowedDomains === void 0 || body?.blocked_domains !== void 0 && blockedDomains === void 0) {
+          await answerJson2(response, HTTP_STATUS.badRequest, { type: "error", error: { type: "invalid_request_error", message: "the domain filters of a worker web-search are string arrays" } });
+          return;
+        }
+        const searchProfile = nonEmptyString2(body, "search_profile");
+        const backend = deps.webSearch;
+        if (backend === void 0) {
+          deps.log?.(`rc selfhost ${session.id}: worker web-search of "${query}" refused: no search backend serves this door`);
+          await answerJson2(response, HTTP_STATUS.ok, { results: [], error: { error_type: "web_search_unavailable", error_message: "this front door serves the Remote Control web-search proxy without a search backend, so no query can be served here" } });
+          return;
+        }
+        const answered = await backend({ query, ...allowedDomains === void 0 ? {} : { allowedDomains }, ...blockedDomains === void 0 ? {} : { blockedDomains }, ...searchProfile === void 0 ? {} : { searchProfile } });
+        deps.log?.(`rc selfhost ${session.id}: worker web-search of "${query}" answered by its backend`);
+        if (isWebSearchRefusal(answered)) {
+          await answerJson2(response, HTTP_STATUS.ok, { results: [], error: { error_type: answered.errorType, error_message: answered.errorMessage } });
+          return;
+        }
+        await answerJson2(response, HTTP_STATUS.ok, { results: answered.map((result) => ({ title: result.title ?? "", url: result.url, snippet: result.snippet ?? "" })) });
+        return;
       }
-      if (session.workerStreams.size === 0 && session.clientStreams.size === 0 && now - session.lastTrafficAt > RC_SELF_HOST_RETENTION_MS) {
-        sessions.delete(session.id);
-      }
+      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;
     }
-  };
-  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");
+    const clientRefusal = credentialRefusal(request7.headers);
+    if (clientRefusal !== void 0) {
+      await unauthorized(response, clientRefusal);
+      return;
+    }
+    if (tail === "events" && method === "POST") {
+      const body = parseJsonObject2(await readBody3(request7.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 (!isRecord4(event) || !isRecord4(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;
     }
-  }, 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;
+    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;
     }
-    for (const minted of session.workerJwts) {
-      if (isLiveCapability(presented, [minted])) {
-        return true;
-      }
+    if (tail === "events/stream" && method === "GET") {
+      await holdStream(session, "clientStreams", () => true, request7, response);
+      return;
     }
-    return false;
-  };
-  const credentialRefusal = (headers) => presentsCredential(headers) ? void 0 : presentationRefusal(headers);
-  const workerRefusal = (headers, session) => presentsWorkerJwt(headers, session) ? void 0 : presentationRefusal(headers);
-  const workerOrCredentialRefusal = (headers, session) => presentsWorkerJwt(headers, session) || presentsCredential(headers) ? void 0 : presentationRefusal(headers);
-  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_NAME}
-id: ${String(event.sequenceNum)}
-data: ${JSON.stringify(envelope)}
-
-`;
-  };
-  const holdStream = async (session, which, wantsReplay, request7, response) => {
-    const url2 = new URL(request7.url, "http://127.0.0.1");
-    const cursor3 = numberOf({ value: url2.searchParams.get("from_sequence_num") }, "value") ?? numberOf({ value: singleHeader2(request7.headers, "last-event-id") }, "value");
-    const replay = cursor3 === void 0 ? [] : session.events.filter((event) => wantsReplay(event) && event.sequenceNum > cursor3);
-    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));
+    if (tail === "client/presence" && method === "POST") {
+      await readBody3(request7.body, CONTROL_BODY_CAP_BYTES);
+      await answerJson2(response, HTTP_STATUS.ok, { refresh_after_seconds: RC_PRESENCE_REFRESH_SECONDS });
+      return;
     }
-    await new Promise((resolve) => {
-      request7.signal.addEventListener("abort", () => {
-        resolve(void 0);
-      }, { once: true });
-    });
-    sink.retire();
-    response.end();
-  };
-  const publish = (session, source, payload) => {
-    const uuid3 = nonEmptyString2(payload, "uuid");
-    const duplicate = uuid3 !== void 0 && session.seenPayloadUuids.has(uuid3);
-    session.sequenceNum += 1;
-    const event = {
-      sequenceNum: session.sequenceNum,
-      eventId: uuid3 ?? 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 (uuid3 !== void 0) {
-      session.seenPayloadUuids.add(uuid3);
-    }
-    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 text2 = JSON.stringify(body);
-    response.start(status, { "content-type": "application/json", "content-length": String(Buffer.byteLength(text2, "utf8")), ...extraHeaders });
-    await response.write(text2);
-    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 refusalMessages = {
-    absent: "the self-hosted Remote Control surface authenticates by the Authorization header, and this call carried none",
-    "not-a-bearer": "the self-hosted Remote Control surface reads a Bearer authorization, and this call's Authorization header did not carry the Bearer scheme word",
-    "doubled-scheme-word": "the self-hosted Remote Control surface reads one Bearer scheme word, and this call's Authorization header carried it twice: a persisted session record holds the whole header value with the scheme word included, so prefixing Bearer onto it presents a different credential",
-    unrecognised: "the self-hosted Remote Control surface did not recognise the presented credential"
-  };
-  const unauthorized = async (response, refusal) => {
-    await answerJson2(response, HTTP_STATUS.unauthorized, { type: "error", error: { type: "authentication_error", message: refusalMessages[refusal] } });
-  };
-  const serveSessionPath = async (session, tail, request7, response) => {
-    const method = request7.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") {
-      const refusal = credentialRefusal(request7.headers);
-      if (refusal !== void 0) {
-        await unauthorized(response, refusal);
-        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 });
+    if (tail === "mark_read" && method === "POST") {
+      await readBody3(request7.body, CONTROL_BODY_CAP_BYTES);
+      await answerJson2(response, HTTP_STATUS.ok, {});
       return;
     }
-    if (tail === "archive" && method === "POST") {
-      const refusal = credentialRefusal(request7.headers);
-      if (refusal !== void 0) {
-        await unauthorized(response, refusal);
-        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`);
+    if (tail === "teleport-events" && method === "POST") {
+      await readBody3(request7.body, CONTROL_BODY_CAP_BYTES);
       await answerJson2(response, HTTP_STATUS.ok, {});
       return;
     }
-    if (tail === "worker" || tail.startsWith("worker/")) {
-      const workerTail = tail === "worker" ? "" : tail.slice("worker/".length);
-      const webProxy = workerTail === "web-fetch" || workerTail === "web-search";
-      const refusal = webProxy ? workerOrCredentialRefusal(request7.headers, session) : workerRefusal(request7.headers, session);
-      if (refusal !== void 0) {
-        await unauthorized(response, refusal);
-        return;
-      }
-      if (workerTail === "" && method === "GET") {
-        await answerJson2(response, HTTP_STATUS.ok, { worker: { external_metadata: session.externalMetadata ?? null } });
+    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 (request7, response) => {
+      const method = request7.method.toUpperCase();
+      const pathname = new URL(request7.url, "http://127.0.0.1").pathname;
+      if (recordMissing()) {
+        await noCredential(response);
         return;
       }
-      if (workerTail === "" && method === "PUT") {
-        const body = parseJsonObject2(await readBody3(request7.body, CONTROL_BODY_CAP_BYTES));
-        const claimedEpoch = numberOf(body, "worker_epoch");
-        if (claimedEpoch !== void 0 && claimedEpoch !== RC_SELF_HOST_WORKER_EPOCH) {
-          await epochStale(response);
+      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;
         }
-        const status = nonEmptyString2(body, "worker_status");
-        if (status !== void 0) {
-          session.workerStatus = status;
-        }
-        if (isRecord5(body?.external_metadata)) {
-          session.externalMetadata = body.external_metadata;
+        const listRefusal = credentialRefusal(request7.headers);
+        if (listRefusal !== void 0) {
+          await unauthorized(response, listRefusal);
+          return;
         }
-        await answerJson2(response, HTTP_STATUS.ok, {});
-        return;
-      }
-      if (workerTail === "register" && method === "POST") {
-        await readBody3(request7.body, CONTROL_BODY_CAP_BYTES);
-        await answerJson2(response, HTTP_STATUS.ok, { worker_epoch: RC_SELF_HOST_WORKER_EPOCH });
+        await answerJson2(response, HTTP_STATUS.ok, { data: [] });
         return;
       }
-      if (workerTail === "heartbeat" && method === "POST") {
-        await readBody3(request7.body, CONTROL_BODY_CAP_BYTES);
-        await answerJson2(response, HTTP_STATUS.ok, {});
+      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 (workerTail === "events" && method === "POST") {
-        const body = parseJsonObject2(await readBody3(request7.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` } });
+      if (pathname === RC_SESSIONS_PATH_PREFIX2) {
+        if (method === "POST") {
+          const createRefusal = credentialRefusal(request7.headers);
+          if (createRefusal !== void 0) {
+            await unauthorized(response, createRefusal);
+            return;
+          }
+          const body = parseJsonObject2(await readBody3(request7.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;
         }
-        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" } });
+        if (method === "GET") {
+          const readRefusal = credentialRefusal(request7.headers);
+          if (readRefusal !== void 0) {
+            await unauthorized(response, readRefusal);
             return;
           }
-          const published = publish(session, RC_SOURCE_WORKER, event.payload);
-          results.push({ event_id: published.eventId, sequence_num: String(published.sequenceNum) });
+          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;
         }
-        sweep();
-        await answerJson2(response, HTTP_STATUS.ok, { results });
-        return;
-      }
-      if (workerTail === "events/stream" && method === "GET") {
-        await holdStream(session, "workerStreams", (event) => event.toWorker, request7, response);
+        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;
       }
-      if (workerTail === "events/delivery" && method === "POST") {
-        await readBody3(request7.body, CONTROL_BODY_CAP_BYTES);
-        await answerJson2(response, HTTP_STATUS.ok, {});
+      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;
       }
-      if (workerTail === "internal-events" && method === "POST") {
-        const body = parseJsonObject2(await readBody3(request7.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 serveSessionPath(sessions.get(id), tail, request7, response);
+    }
+  };
+  const answerServerJson = (response, status, body) => {
+    const text2 = JSON.stringify(body);
+    response.writeHead(status, { "content-type": "application/json", "content-length": String(Buffer.byteLength(text2, "utf8")) });
+    response.end(text2);
+  };
+  const local = {
+    parsesHost: (host) => host === RC_SELF_HOST_OAUTH_HOST,
+    serve: async (host, request7, response) => {
+      const method = (request7.method ?? "").toUpperCase();
+      const pathname = new URL(request7.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 readBody3(request7, CONTROL_BODY_CAP_BYTES));
+          const record2 = deps.credentialRecord();
+          if (record2 === 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: record2.accessToken, refresh_token: record2.refreshToken, expires_in: RC_SELF_HOST_OAUTH_TOKEN_TTL_SECONDS, scope: RC_SELF_HOST_SCOPE_LIST.join(" ") });
+          return true;
         }
-        await answerJson2(response, HTTP_STATUS.ok, {});
-        return;
-      }
-      if (workerTail === "internal-events" && method === "GET") {
-        const url2 = new URL(request7.url, "http://127.0.0.1");
-        const cursor3 = url2.searchParams.get("cursor");
-        const from = cursor3 === null ? 0 : session.internalEvents.findIndex((event) => event.cursor === cursor3) + 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 readBody3(request7.body, CONTROL_BODY_CAP_BYTES);
-        await answerJson2(response, HTTP_STATUS.ok, {});
-        return;
-      }
-      if (workerTail === "web-fetch" && method === "POST") {
-        const body = parseJsonObject2(await readBody3(request7.body, CONTROL_BODY_CAP_BYTES));
-        const target = nonEmptyString2(body, "url");
-        if (target === void 0) {
-          await answerJson2(response, HTTP_STATUS.badRequest, { type: "error", error: { type: "invalid_request_error", message: "a worker web-fetch carries one url" } });
-          return;
-        }
-        const outcome = await deps.webFetch(target);
-        if (outcome.kind === "fetched") {
-          const answer = { url: target, destination_url: outcome.destinationUrl, text: outcome.text, ...outcome.contentType === void 0 ? {} : { content_type: outcome.contentType } };
-          if (Buffer.byteLength(JSON.stringify(answer), "utf8") > RC_WEB_FETCH_MAX_BYTES) {
-            deps.log?.(`rc selfhost ${session.id}: worker web-fetch of ${target} escaped past the reader cap when framed`);
-            await answerJson2(response, HTTP_STATUS.ok, { error: { error_type: "web_fetch_too_large", error_message: `the answer for ${target} exceeds the ${String(RC_WEB_FETCH_MAX_BYTES)} byte cap the CLI's proxy client reads` } });
-            return;
-          }
-          deps.log?.(`rc selfhost ${session.id}: worker web-fetch served ${target} as ${outcome.destinationUrl}`);
-          await answerJson2(response, HTTP_STATUS.ok, answer);
-          return;
-        }
-        deps.log?.(`rc selfhost ${session.id}: worker web-fetch of ${target} refused: ${outcome.errorType}`);
-        await answerJson2(response, HTTP_STATUS.ok, { error: { error_type: outcome.errorType, error_message: outcome.errorMessage } });
-        return;
-      }
-      if (workerTail === "web-search" && method === "POST") {
-        const body = parseJsonObject2(await readBody3(request7.body, CONTROL_BODY_CAP_BYTES));
-        const query = nonEmptyString2(body, "query");
-        if (query === void 0) {
-          await answerJson2(response, HTTP_STATUS.badRequest, { type: "error", error: { type: "invalid_request_error", message: "a worker web-search carries one query" } });
-          return;
-        }
-        const allowedDomains = stringArray(body, "allowed_domains");
-        const blockedDomains = stringArray(body, "blocked_domains");
-        if (body?.allowed_domains !== void 0 && allowedDomains === void 0 || body?.blocked_domains !== void 0 && blockedDomains === void 0) {
-          await answerJson2(response, HTTP_STATUS.badRequest, { type: "error", error: { type: "invalid_request_error", message: "the domain filters of a worker web-search are string arrays" } });
-          return;
-        }
-        const searchProfile = nonEmptyString2(body, "search_profile");
-        const backend = deps.webSearch;
-        if (backend === void 0) {
-          deps.log?.(`rc selfhost ${session.id}: worker web-search of "${query}" refused: no search backend serves this door`);
-          await answerJson2(response, HTTP_STATUS.ok, { results: [], error: { error_type: "web_search_unavailable", error_message: "this front door serves the Remote Control web-search proxy without a search backend, so no query can be served here" } });
-          return;
-        }
-        const answered = await backend({ query, ...allowedDomains === void 0 ? {} : { allowedDomains }, ...blockedDomains === void 0 ? {} : { blockedDomains }, ...searchProfile === void 0 ? {} : { searchProfile } });
-        deps.log?.(`rc selfhost ${session.id}: worker web-search of "${query}" answered by its backend`);
-        if (isWebSearchRefusal(answered)) {
-          await answerJson2(response, HTTP_STATUS.ok, { results: [], error: { error_type: answered.errorType, error_message: answered.errorMessage } });
-          return;
-        }
-        await answerJson2(response, HTTP_STATUS.ok, { results: answered.map((result) => ({ title: result.title ?? "", url: result.url, snippet: result.snippet ?? "" })) });
-        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;
-    }
-    const clientRefusal = credentialRefusal(request7.headers);
-    if (clientRefusal !== void 0) {
-      await unauthorized(response, clientRefusal);
-      return;
-    }
-    if (tail === "events" && method === "POST") {
-      const body = parseJsonObject2(await readBody3(request7.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, request7, response);
-      return;
-    }
-    if (tail === "client/presence" && method === "POST") {
-      await readBody3(request7.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 readBody3(request7.body, CONTROL_BODY_CAP_BYTES);
-      await answerJson2(response, HTTP_STATUS.ok, {});
-      return;
-    }
-    if (tail === "teleport-events" && method === "POST") {
-      await readBody3(request7.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 (request7, response) => {
-      const method = request7.method.toUpperCase();
-      const pathname = new URL(request7.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;
-        }
-        const listRefusal = credentialRefusal(request7.headers);
-        if (listRefusal !== void 0) {
-          await unauthorized(response, listRefusal);
-          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") {
-          const createRefusal = credentialRefusal(request7.headers);
-          if (createRefusal !== void 0) {
-            await unauthorized(response, createRefusal);
-            return;
-          }
-          const body = parseJsonObject2(await readBody3(request7.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") {
-          const readRefusal = credentialRefusal(request7.headers);
-          if (readRefusal !== void 0) {
-            await unauthorized(response, readRefusal);
-            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, request7, response);
-    }
-  };
-  const answerServerJson = (response, status, body) => {
-    const text2 = JSON.stringify(body);
-    response.writeHead(status, { "content-type": "application/json", "content-length": String(Buffer.byteLength(text2, "utf8")) });
-    response.end(text2);
-  };
-  const local = {
-    parsesHost: (host) => host === RC_SELF_HOST_OAUTH_HOST,
-    serve: async (host, request7, response) => {
-      const method = (request7.method ?? "").toUpperCase();
-      const pathname = new URL(request7.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 readBody3(request7, CONTROL_BODY_CAP_BYTES));
-          const record2 = deps.credentialRecord();
-          if (record2 === 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: record2.accessToken, refresh_token: record2.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 === "GET" && pathname === "/v1/oauth/hello") {
+          answerServerJson(response, HTTP_STATUS.ok, {});
+          return true;
+        }
+        return false;
       }
       if (method === "POST" && pathname.startsWith("/api/eval/")) {
         await readBody3(request7, CONTROL_BODY_CAP_BYTES);
@@ -74933,94 +74677,959 @@ data: ${JSON.stringify(envelope)}
 }
 
 // src/frontdoor/rcSelfHostMint.ts
-var import_node_path35 = __toESM(require("node:path"), 1);
 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(value2) {
+function isRecord5(value2) {
   return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
 }
-function readJsonObject(fs20, file2) {
-  const raw = fs20.readFileUtf8(file2);
-  if (raw === void 0) {
-    return void 0;
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(raw);
-  } catch {
-    return void 0;
+function readJsonObject(fs20, file2) {
+  const raw = fs20.readFileUtf8(file2);
+  if (raw === void 0) {
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return void 0;
+  }
+  return isRecord5(parsed) ? parsed : void 0;
+}
+function readRcSelfHostRecord(fs20, frontdoorDir) {
+  const parsed = readJsonObject(fs20, import_node_path34.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_path34.default.join(deps.identitiesDir, deps.identity);
+  const credentialsFile = import_node_path34.default.join(identityDir, CREDENTIALS_FILE);
+  const claudeJsonFile = import_node_path34.default.join(identityDir, CLAUDE_JSON2);
+  const recordDir = import_node_path34.default.join(deps.frontdoorDir, RC_SELF_HOST_RECORD_DIR);
+  const recordFile = import_node_path34.default.join(recordDir, RC_SELF_HOST_RECORD_FILE);
+  const previousRecord = readRcSelfHostRecord(deps.fs, deps.frontdoorDir);
+  const existingCredentials = readJsonObject(deps.fs, credentialsFile);
+  const existingOauth = isRecord5(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_path34.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 = (value2) => isRecord5(value2) ? value2 : {};
+  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
+    },
+    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/rcCommands.ts
+var MINTED_TOKEN_RANDOM_BYTES = 32;
+function reportControlWrite(what, session, result, json2, extra = {}) {
+  if (!result.ok) {
+    throw new Error(result.message);
+  }
+  if (json2 === true) {
+    printJson({ session, ...result.requestId === void 0 ? {} : { request: result.requestId }, sequenceNums: result.sequenceNums, ...extra });
+    return;
+  }
+  console.log(`${what} on ${session}${result.requestId === void 0 ? "" : `: request ${result.requestId}`} sequence_num ${result.sequenceNums.join(", ")}`);
+}
+function formatRcSessionList(sessions) {
+  if (sessions.length === 0) {
+    return ["no Remote Control sessions observed"];
+  }
+  return sessions.map((session) => `${session.id}  created ${new Date(session.createdAt).toISOString()}  last seen ${new Date(session.lastSeenAt).toISOString()}`);
+}
+function formatRcSessionStatus(statuses) {
+  if (statuses.length === 0) {
+    return ["no Remote Control sessions observed"];
+  }
+  const lines = [];
+  for (const status of statuses) {
+    lines.push(`${status.id}  created ${new Date(status.createdAt).toISOString()}  last seen ${new Date(status.lastSeenAt).toISOString()}`);
+    const worker = status.workerState === void 0 && status.workerIdleSeconds === void 0 ? "not observed" : [
+      status.workerState === void 0 ? "state unknown" : `state ${status.workerState.value} since ${new Date(status.workerState.observedAt).toISOString()}`,
+      status.workerIdleSeconds === void 0 ? "idle unknown" : `idle ${String(status.workerIdleSeconds.value)} s as of ${new Date(status.workerIdleSeconds.observedAt).toISOString()}`
+    ].join(", ");
+    lines.push(`  worker: ${worker}`);
+    if (status.pending.length === 0) {
+      lines.push("  pending: none");
+    } else {
+      lines.push("  pending:");
+      for (const pending of status.pending) {
+        lines.push(...formatRcPendingList([pending]).map((line) => `    ${line}`));
+      }
+    }
+  }
+  return lines;
+}
+function formatRcPendingList(pending) {
+  if (pending.length === 0) {
+    return ["no pending control requests observed"];
+  }
+  return pending.map((request7) => `${request7.sessionId}  ${request7.requestId}  ${request7.type}${request7.summary === "" ? "" : `  ${request7.summary}`}  observed ${new Date(request7.observedAt).toISOString()}`);
+}
+function eventExcerpt(text2) {
+  return text2.length <= RC_PENDING_SUMMARY_EXCERPT_CHARS ? text2 : `${text2.slice(0, RC_PENDING_SUMMARY_EXCERPT_CHARS)}...`;
+}
+function formatRcStreamEvent(event) {
+  const { envelope } = event;
+  const sketch = envelope.payload === void 0 ? "" : `  ${eventExcerpt(JSON.stringify(envelope.payload))}`;
+  return `${event.session}  ${envelope.event_type}  sequence_num ${String(envelope.sequence_num)}  source ${envelope.source}${sketch}`;
+}
+function formatRcSelfHostMint(result) {
+  return [
+    `identity:       ${result.identity} (organisation ${result.organizationUuid})`,
+    `credential:     ${result.credentialsFile}${result.replaced ? " (replacing this door's previous mint)" : ""}`,
+    `account block:  ${result.claudeJsonFile} (oauthAccount and the feature-cache seed merged in)`,
+    `door record:    ${result.recordFile} (the copy the door's served surface authenticates against)`,
+    "next:           start the door with AGENT_SHIM_FRONTDOOR_RC_SELF_HOST=1 and its transparent surface pointed at the interception port, then launch this identity and switch Remote Control on; no claude.ai login is involved"
+  ];
+}
+function frontDoorRcControlFromState(fsPort, paths) {
+  const state = readFrontDoorState(fsPort, paths.frontdoorStateFile);
+  if (state?.port === void 0) {
+    throw new Error("the front door is not serving: Remote Control sessions are observed only while it runs, so start a session through the door first");
+  }
+  const ca = fsPort.readFileUtf8(paths.frontdoorCaCertFile);
+  if (ca === void 0) {
+    throw new Error(`the front door's CA certificate is missing at ${paths.frontdoorCaCertFile}, so its control listener cannot be authenticated`);
+  }
+  const token = fsPort.readFileUtf8(paths.frontdoorControlTokenFile)?.trim();
+  if (token === void 0 || token === "") {
+    throw new Error(`the serving front door's control token is missing at ${paths.frontdoorControlTokenFile}`);
+  }
+  return frontDoorRcControl(realRcControlTransport(state.port, ca), token);
+}
+function frontDoorRcApiFromState(fsPort, paths) {
+  const state = readFrontDoorState(fsPort, paths.frontdoorStateFile);
+  if (state?.port === void 0) {
+    throw new Error("the front door is not serving: Remote Control sessions are observed only while it runs, so start a session through the door first");
+  }
+  const ca = fsPort.readFileUtf8(paths.frontdoorCaCertFile);
+  if (ca === void 0) {
+    throw new Error(`the front door's CA certificate is missing at ${paths.frontdoorCaCertFile}, so its typed API cannot be authenticated`);
+  }
+  const token = fsPort.readFileUtf8(paths.frontdoorControlTokenFile)?.trim();
+  if (token === void 0 || token === "") {
+    throw new Error(`the serving front door's control token is missing at ${paths.frontdoorControlTokenFile}`);
+  }
+  return frontDoorRcApiClient(state.port, ca, token);
+}
+function registerRcCommand(frontdoor, paths) {
+  const rc = withExamples(
+    frontdoor.command("rc").description("Observe the Remote Control sessions passing through the front door, watch the stream their attached client receives, send a prompt into one, answer its pending control requests, and steer one with the client half's own control requests (interrupt, model, permission mode, end-session, the usage and context queries, read-file, file-suggestions, keep-alive, and the mcp_* family)."),
+    ["agent-shim frontdoor rc list", "agent-shim frontdoor rc pending"]
+  );
+  withExamples(
+    rc.command("list").description("List the Remote Control sessions the front door has observed, with when each was created and last seen. Read-only.").option("--json", "Print the sessions as JSON.").action(async (options) => {
+      const sessions = await frontDoorRcControlFromState(realFarmFs, paths).listSessions();
+      if (options.json === true) {
+        printJson({ sessions });
+        return;
+      }
+      for (const line of formatRcSessionList(sessions)) {
+        console.log(line);
+      }
+    }),
+    ["agent-shim frontdoor rc list", "agent-shim frontdoor rc list --json"]
+  );
+  withExamples(
+    rc.command("status").description("Report each observed Remote Control session's worker state and idle from its latest observed heartbeat and registration, with its pending control requests. Read-only.").argument("[session]", "One cse_ session id, as `frontdoor rc list` shows it; every observed session when omitted.").option("--json", "Print the statuses as JSON.").action(async (session, options) => {
+      const statuses = await frontDoorRcControlFromState(realFarmFs, paths).statusOf(session);
+      if (options.json === true) {
+        printJson({ statuses });
+        return;
+      }
+      for (const line of formatRcSessionStatus(statuses)) {
+        console.log(line);
+      }
+    }),
+    ["agent-shim frontdoor rc status", "agent-shim frontdoor rc status cse_00000000-0000-4000-8000-000000000000 --json"]
+  );
+  withExamples(
+    rc.command("pending").description("List the control requests (tool and plan approvals above all) the front door has observed and that are still awaiting an answer. Read-only.").argument("[session]", "One cse_ session id, as `frontdoor rc list` shows it; every observed session when omitted.").option("--json", "Print the pending requests as JSON.").action(async (session, options) => {
+      const pending = await frontDoorRcControlFromState(realFarmFs, paths).pendingOf(session);
+      if (options.json === true) {
+        printJson({ pending });
+        return;
+      }
+      for (const line of formatRcPendingList(pending)) {
+        console.log(line);
+      }
+    }),
+    ["agent-shim frontdoor rc pending", "agent-shim frontdoor rc pending --json"]
+  );
+  withExamples(
+    rc.command("send").description("Send a text prompt into one observed Remote Control session, arriving as a message from an attached client would.").requiredOption("--session <id>", "The cse_ session id, as `frontdoor rc list` shows it.").requiredOption("--text <text>", "The prompt text to deliver.").option("--json", "Print the delivery result as JSON.").action(async (options) => {
+      const result = await frontDoorRcControlFromState(realFarmFs, paths).sendPrompt(options.session, options.text);
+      if (!result.ok) {
+        throw new Error(result.message);
+      }
+      if (options.json === true) {
+        printJson({ session: options.session, sequenceNums: result.sequenceNums });
+        return;
+      }
+      console.log(`sent to ${options.session}: sequence_num ${result.sequenceNums.join(", ")}`);
+    }),
+    ['agent-shim frontdoor rc send --session cse_00000000-0000-4000-8000-000000000000 --text "run the tests"']
+  );
+  withExamples(
+    rc.command("answer").description("Answer one pending control request on an observed session, approving or denying it as an attached client's approval would.").requiredOption("--session <id>", "The cse_ session id, as `frontdoor rc list` shows it.").requiredOption("--request <id>", "The control request's id, as `frontdoor rc pending` shows it.").option("--approve", "Approve the request.").option("--deny", "Deny the request.").option("--text <text>", "The denial message the worker sees; applies to --deny only.").option("--json", "Print the delivery result as JSON.").action(async (options) => {
+      if (options.approve === options.deny) {
+        throw new UsageError("answer exactly one way: pass --approve or --deny, not both and not neither");
+      }
+      if (options.approve === true && options.text !== void 0) {
+        throw new UsageError("--text is the denial message; an approval carries no text (the protocol's allow result has no message field)");
+      }
+      const result = await frontDoorRcControlFromState(realFarmFs, paths).answerRequest(options.session, options.request, { approve: options.approve === true, message: options.deny === true ? options.text : void 0 });
+      if (!result.ok) {
+        throw new Error(result.message);
+      }
+      if (options.json === true) {
+        printJson({ session: options.session, request: options.request, sequenceNums: result.sequenceNums });
+        return;
+      }
+      console.log(`${options.approve === true ? "approved" : "denied"} ${options.request} on ${options.session}: sequence_num ${result.sequenceNums.join(", ")}`);
+    }),
+    [
+      "agent-shim frontdoor rc answer --session cse_00000000-0000-4000-8000-000000000000 --request req_00000000-0000-4000-8000-000000000000 --approve",
+      'agent-shim frontdoor rc answer --session cse_00000000-0000-4000-8000-000000000000 --request req_00000000-0000-4000-8000-000000000000 --deny --text "not today"'
+    ]
+  );
+  withExamples(
+    rc.command("interrupt").description("Interrupt one observed Remote Control session's running turn, as an attached client's stop button would. Queued commands survive the interrupt.").requiredOption("--session <id>", "The cse_ session id, as `frontdoor rc list` shows it.").option("--json", "Print the delivery result as JSON.").action(async (options) => {
+      reportControlWrite("interrupted", options.session, await frontDoorRcControlFromState(realFarmFs, paths).interruptSession(options.session), options.json);
+    }),
+    ["agent-shim frontdoor rc interrupt --session cse_00000000-0000-4000-8000-000000000000"]
+  );
+  withExamples(
+    rc.command("set-model").description("Set the model one observed Remote Control session's subsequent turns use, as an attached client's model picker would.").requiredOption("--session <id>", "The cse_ session id, as `frontdoor rc list` shows it.").requiredOption("--model <model>", "The model id to switch the session to.").option("--json", "Print the delivery result as JSON.").action(async (options) => {
+      reportControlWrite(`set model ${options.model}`, options.session, await frontDoorRcControlFromState(realFarmFs, paths).setModel(options.session, options.model), options.json, { model: options.model });
+    }),
+    ["agent-shim frontdoor rc set-model --session cse_00000000-0000-4000-8000-000000000000 --model claude-opus-5-5"]
+  );
+  withExamples(
+    rc.command("set-permission-mode").description("Set one observed Remote Control session's permission mode, as an attached client's mode switcher would.").requiredOption("--session <id>", "The cse_ session id, as `frontdoor rc list` shows it.").requiredOption("--mode <mode>", `The permission mode to set; one of the SDK's own modes (${RC_PERMISSION_MODES.join(", ")}).`).option("--json", "Print the delivery result as JSON.").action(async (options) => {
+      if (!isRcPermissionMode(options.mode)) {
+        throw new UsageError(`--mode must be one of the SDK's own permission modes (${RC_PERMISSION_MODES.join(", ")}), not "${options.mode}"`);
+      }
+      reportControlWrite(`set permission mode ${options.mode}`, options.session, await frontDoorRcControlFromState(realFarmFs, paths).setPermissionMode(options.session, options.mode), options.json, { mode: options.mode });
+    }),
+    [
+      "agent-shim frontdoor rc set-permission-mode --session cse_00000000-0000-4000-8000-000000000000 --mode plan",
+      "agent-shim frontdoor rc set-permission-mode --session cse_00000000-0000-4000-8000-000000000000 --mode acceptEdits"
+    ]
+  );
+  withExamples(
+    rc.command("end-session").description("End one observed Remote Control session, as an attached client closing it would: the worker aborts its turn and shuts down on receipt of the request.").requiredOption("--session <id>", "The cse_ session id, as `frontdoor rc list` shows it.").option("--reason <text>", "The reason the worker's own log names; omitted means the protocol's unspecified form.").option("--json", "Print the delivery result as JSON.").action(async (options) => {
+      reportControlWrite("ended", options.session, await frontDoorRcControlFromState(realFarmFs, paths).endSession(options.session, options.reason), options.json);
+    }),
+    ["agent-shim frontdoor rc end-session --session cse_00000000-0000-4000-8000-000000000000 --reason done for today"]
+  );
+  withExamples(
+    rc.command("get-usage").description("Ask one observed session's worker for its structured usage (session totals plus the plan's rate limits). The worker's answer arrives on `frontdoor rc watch` as the control_response echoing the printed request id.").requiredOption("--session <id>", "The cse_ session id, as `frontdoor rc list` shows it.").option("--skip-behaviors", "Skip the worker's local-transcript scan that fills the answer's behaviours section.").option("--json", "Print the delivery result as JSON.").action(async (options) => {
+      reportControlWrite("requested usage", options.session, await frontDoorRcControlFromState(realFarmFs, paths).getUsage(options.session, options.skipBehaviors === true ? true : void 0), options.json);
+    }),
+    ["agent-shim frontdoor rc get-usage --session cse_00000000-0000-4000-8000-000000000000 --skip-behaviors"]
+  );
+  withExamples(
+    rc.command("get-context-usage").description("Ask one observed session's worker for its context-window breakdown by category. The worker's answer arrives on `frontdoor rc watch` as the control_response echoing the printed request id.").requiredOption("--session <id>", "The cse_ session id, as `frontdoor rc list` shows it.").option("--detail <level>", `The detail level; one of the SDK's own levels (${RC_CONTEXT_USAGE_DETAILS.join(", ")}); the worker defaults to full.`).option("--json", "Print the delivery result as JSON.").action(async (options) => {
+      if (options.detail !== void 0 && !isRcContextUsageDetail(options.detail)) {
+        throw new UsageError(`--detail must be one of the SDK's own context-usage levels (${RC_CONTEXT_USAGE_DETAILS.join(", ")}), not "${options.detail}"`);
+      }
+      reportControlWrite("requested context usage", options.session, await frontDoorRcControlFromState(realFarmFs, paths).getContextUsage(options.session, options.detail), options.json);
+    }),
+    ["agent-shim frontdoor rc get-context-usage --session cse_00000000-0000-4000-8000-000000000000 --detail summary"]
+  );
+  withExamples(
+    rc.command("read-file").description("Ask one observed session's worker to read one file from the session filesystem, gated by its own read-permission rules. The worker's answer arrives on `frontdoor rc watch` as the control_response echoing the printed request id.").requiredOption("--session <id>", "The cse_ session id, as `frontdoor rc list` shows it.").requiredOption("--path <path>", "The file's path, as the worker resolves it against the session's cwd.").option("--max-bytes <n>", "The byte cap on the read, a positive whole number.").option("--encoding <encoding>", `How the answer encodes the contents; one of the SDK's own encodings (${RC_READ_FILE_ENCODINGS.join(", ")}).`).option("--json", "Print the delivery result as JSON.").action(async (options) => {
+      if (options.maxBytes !== void 0 && !/^[1-9][0-9]*$/.test(options.maxBytes)) {
+        throw new UsageError(`--max-bytes must be a positive whole number of bytes, not "${options.maxBytes}"`);
+      }
+      if (options.encoding !== void 0 && !isRcReadFileEncoding(options.encoding)) {
+        throw new UsageError(`--encoding must be one of the SDK's own read-file encodings (${RC_READ_FILE_ENCODINGS.join(", ")}), not "${options.encoding}"`);
+      }
+      reportControlWrite(`requested a read of ${options.path}`, options.session, await frontDoorRcControlFromState(realFarmFs, paths).readFile(options.session, options.path, { ...options.maxBytes === void 0 ? {} : { maxBytes: Number(options.maxBytes) }, ...options.encoding === void 0 ? {} : { encoding: options.encoding } }), options.json, { path: options.path });
+    }),
+    [
+      "agent-shim frontdoor rc read-file --session cse_00000000-0000-4000-8000-000000000000 --path src/index.ts",
+      "agent-shim frontdoor rc read-file --session cse_00000000-0000-4000-8000-000000000000 --path screenshot.png --encoding base64 --max-bytes 65536"
+    ]
+  );
+  withExamples(
+    rc.command("file-suggestions").description("Ask one observed session's worker for its at-mention file suggestions for a partial path prefix, the same fuzzy-matched results the TUI shows. The worker's answer arrives on `frontdoor rc watch` as the control_response echoing the printed request id.").requiredOption("--session <id>", "The cse_ session id, as `frontdoor rc list` shows it.").requiredOption("--query <prefix>", "The partial path prefix to fuzzy-match; the empty string is the root listing.").option("--json", "Print the delivery result as JSON.").action(async (options) => {
+      reportControlWrite(`requested file suggestions for "${options.query}"`, options.session, await frontDoorRcControlFromState(realFarmFs, paths).fileSuggestions(options.session, options.query), options.json);
+    }),
+    ['agent-shim frontdoor rc file-suggestions --session cse_00000000-0000-4000-8000-000000000000 --query "src/frontdoor/rc"']
+  );
+  withExamples(
+    rc.command("keep-alive").description("Send one liveness heartbeat into an observed session: the payload every receiver ignores by its own contract, useful to keep the client half's stream warm without saying anything.").requiredOption("--session <id>", "The cse_ session id, as `frontdoor rc list` shows it.").option("--json", "Print the delivery result as JSON.").action(async (options) => {
+      reportControlWrite("sent a keep-alive", options.session, await frontDoorRcControlFromState(realFarmFs, paths).keepAlive(options.session), options.json);
+    }),
+    ["agent-shim frontdoor rc keep-alive --session cse_00000000-0000-4000-8000-000000000000"]
+  );
+  withExamples(
+    rc.command("mcp-status").description("Ask one observed session's worker for the status of its MCP server connections. The worker's answer arrives on `frontdoor rc watch` as the control_response echoing the printed request id.").requiredOption("--session <id>", "The cse_ session id, as `frontdoor rc list` shows it.").option("--json", "Print the delivery result as JSON.").action(async (options) => {
+      reportControlWrite("requested MCP status", options.session, await frontDoorRcControlFromState(realFarmFs, paths).mcpStatus(options.session), options.json);
+    }),
+    ["agent-shim frontdoor rc mcp-status --session cse_00000000-0000-4000-8000-000000000000"]
+  );
+  withExamples(
+    rc.command("mcp-reconnect").description("Ask one observed session's worker to reconnect one MCP server, named exactly as `mcp-status` reports it.").requiredOption("--session <id>", "The cse_ session id, as `frontdoor rc list` shows it.").requiredOption("--server <name>", "The MCP server's name, as `mcp-status` reports it.").option("--json", "Print the delivery result as JSON.").action(async (options) => {
+      reportControlWrite(`requested a reconnect of MCP server ${options.server}`, options.session, await frontDoorRcControlFromState(realFarmFs, paths).mcpReconnect(options.session, options.server), options.json);
+    }),
+    ["agent-shim frontdoor rc mcp-reconnect --session cse_00000000-0000-4000-8000-000000000000 --server github"]
+  );
+  withExamples(
+    rc.command("mcp-authenticate").description("Start one MCP server's OAuth handshake on an observed session, naming the redirect URI the flow redirects back to. The worker's answer arrives on `frontdoor rc watch` as the control_response echoing the printed request id.").requiredOption("--session <id>", "The cse_ session id, as `frontdoor rc list` shows it.").requiredOption("--server <name>", "The MCP server's name, as `mcp-status` reports it.").requiredOption("--redirect-uri <uri>", "The URI the server's OAuth flow redirects back to.").option("--json", "Print the delivery result as JSON.").action(async (options) => {
+      reportControlWrite(`requested authentication of MCP server ${options.server}`, options.session, await frontDoorRcControlFromState(realFarmFs, paths).mcpAuthenticate(options.session, options.server, options.redirectUri), options.json);
+    }),
+    ["agent-shim frontdoor rc mcp-authenticate --session cse_00000000-0000-4000-8000-000000000000 --server github --redirect-uri https://example.com/oauth/callback"]
+  );
+  withExamples(
+    rc.command("mcp-oauth-callback-url").description("Hand one MCP server's OAuth callback URL to an observed session's worker, completing the handshake `mcp-authenticate` started. The worker's answer arrives on `frontdoor rc watch` as the control_response echoing the printed request id.").requiredOption("--session <id>", "The cse_ session id, as `frontdoor rc list` shows it.").requiredOption("--server <name>", "The MCP server's name, as `mcp-status` reports it.").requiredOption("--callback-url <url>", "The callback URL the browser landed on.").option("--json", "Print the delivery result as JSON.").action(async (options) => {
+      reportControlWrite(`handed MCP server ${options.server} its OAuth callback`, options.session, await frontDoorRcControlFromState(realFarmFs, paths).mcpOAuthCallbackUrl(options.session, options.server, options.callbackUrl), options.json);
+    }),
+    ["agent-shim frontdoor rc mcp-oauth-callback-url --session cse_00000000-0000-4000-8000-000000000000 --server github --callback-url https://example.com/oauth/callback?code=x"]
+  );
+  withExamples(
+    rc.command("watch").description("Print the observed sessions' client read stream events as they arrive, the approvals the door's held stream receives above all, until Ctrl-C leaves. Read-only.").argument("[session]", "One cse_ session id, as `frontdoor rc list` shows it; every observed session when omitted.").option("--json", "Print each event as one JSON line as it arrives.").action(async (session, options) => {
+      const client = frontDoorRcApiFromState(realFarmFs, paths);
+      const leave = new AbortController();
+      const onInterrupt = () => {
+        leave.abort();
+      };
+      process.once("SIGINT", onInterrupt);
+      try {
+        for await (const event of await client.rc.subscribe(session === void 0 ? {} : { session }, { signal: leave.signal })) {
+          if (options.json === true) {
+            console.log(JSON.stringify(event));
+            continue;
+          }
+          console.log(formatRcStreamEvent(event));
+        }
+      } catch (error62) {
+        if (!leave.signal.aborted) {
+          throw error62;
+        }
+      } finally {
+        process.off("SIGINT", onInterrupt);
+      }
+    }),
+    ["agent-shim frontdoor rc watch", "agent-shim frontdoor rc watch cse_00000000-0000-4000-8000-000000000000 --json"]
+  );
+  const selfhost = withExamples(
+    rc.command("selfhost").description("Mint the local credential behind the door's self-hosted Remote Control surface: the opt-in mode (AGENT_SHIM_FRONTDOOR_RC_SELF_HOST=1 in the door's environment) where the door serves the CCR surface itself and a session activates Remote Control with no Anthropic credential anywhere."),
+    ["agent-shim frontdoor rc selfhost mint rig"]
+  );
+  withExamples(
+    selfhost.command("mint").description("Mint the local OAuth credential, account block and feature-cache seed one identity needs to activate Remote Control against the door's own served surface, and record the door-side copy the surface authenticates against. Refuses to replace a real claude.ai login unless --force. Never prints a token.").argument("<identity>", "The identity to mint into, as `agent-shim identity list` names it.").option("--force", "Replace an existing OAuth credential this door did not mint.").option("--json", "Print the mint result as JSON.").action((identity, options) => {
+      const result = mintRcSelfHostCredential({
+        fs: realFarmFs,
+        identitiesDir: paths.identitiesDir,
+        frontdoorDir: paths.frontdoorDir,
+        identity,
+        newUuid: import_node_crypto14.randomUUID,
+        randomToken: () => (0, import_node_crypto14.randomBytes)(MINTED_TOKEN_RANDOM_BYTES).toString("base64url"),
+        force: options.force === true,
+        now: () => Date.now()
+      });
+      if (options.json === true) {
+        printJson(result);
+        return;
+      }
+      for (const line of formatRcSelfHostMint(result)) {
+        console.log(line);
+      }
+    }),
+    ["agent-shim frontdoor rc selfhost mint rig", "agent-shim frontdoor rc selfhost mint rig --force"]
+  );
+}
+
+// src/frontdoor/rcCredentialStore.ts
+var import_node_path35 = __toESM(require("node:path"), 1);
+function isSafeSessionId(sessionId) {
+  return /^[A-Za-z0-9_-]+$/.test(sessionId);
+}
+function isRecord6(value2) {
+  return typeof value2 === "object" && value2 !== null && !Array.isArray(value2);
+}
+function credentialOfJson(parsed) {
+  if (!isRecord6(parsed)) {
+    return void 0;
+  }
+  const { authorization, anthropicVersion, anthropicClientPlatform } = parsed;
+  if (typeof authorization !== "string" || authorization === "") {
+    return void 0;
+  }
+  return {
+    authorization,
+    anthropicVersion: typeof anthropicVersion === "string" ? anthropicVersion : void 0,
+    anthropicClientPlatform: typeof anthropicClientPlatform === "string" ? anthropicClientPlatform : void 0
+  };
+}
+function sequenceNumOfJson(value2) {
+  return typeof value2 === "number" && Number.isInteger(value2) && value2 >= 0 ? value2 : void 0;
+}
+function createRcCredentialStore(fs20, dir) {
+  fs20.mkdirPrivate(dir);
+  const fileFor = (sessionId) => import_node_path35.default.join(dir, `${sessionId}.json`);
+  const readParsed = (sessionId) => {
+    const raw = fs20.readFileUtf8(fileFor(sessionId));
+    if (raw === void 0) {
+      return void 0;
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      return void 0;
+    }
+    return isRecord6(parsed) ? parsed : void 0;
+  };
+  return {
+    read: (sessionId) => {
+      if (!isSafeSessionId(sessionId)) {
+        return void 0;
+      }
+      return credentialOfJson(readParsed(sessionId));
+    },
+    write: (sessionId, credential) => {
+      if (!isSafeSessionId(sessionId)) {
+        return;
+      }
+      const cursor3 = sequenceNumOfJson(readParsed(sessionId)?.highestSequenceNum);
+      const record2 = { ...credential, ...cursor3 === void 0 ? {} : { highestSequenceNum: cursor3 } };
+      fs20.writeFilePrivate(fileFor(sessionId), `${JSON.stringify(record2, null, 2)}
+`);
+    },
+    readCursor: (sessionId) => {
+      if (!isSafeSessionId(sessionId)) {
+        return void 0;
+      }
+      return sequenceNumOfJson(readParsed(sessionId)?.highestSequenceNum);
+    },
+    writeCursor: (sessionId, highestSequenceNum) => {
+      if (!isSafeSessionId(sessionId)) {
+        return;
+      }
+      const credential = credentialOfJson(readParsed(sessionId));
+      const record2 = credential === void 0 ? { highestSequenceNum } : { ...credential, highestSequenceNum };
+      fs20.writeFilePrivate(fileFor(sessionId), `${JSON.stringify(record2, null, 2)}
+`);
+    },
+    remove: (sessionId) => {
+      if (!isSafeSessionId(sessionId)) {
+        return;
+      }
+      fs20.removeRecursive(fileFor(sessionId));
+    }
+  };
+}
+
+// src/frontdoor/rcClientPage.ts
+var RC_CLIENT_PATH = "/__agent-shim/client";
+var RC_CLIENT_PAGE_SCRIPT = `'use strict';
+// The door's typed API as this page speaks it: the oRPC RPC protocol over plain fetch, which is one POST per procedure with a {"json": input} body and a {"json": output} answer, so no client library is needed. These helpers are plain top-level functions (not boot-scoped) so the page's tests can evaluate this script outside a browser and drive them against a mounted listener.
+var API_PREFIX = '/__agent-shim/orpc';
+var TOKEN_KEY = 'agent-shim-rc-token';
+var token = null;
+
+function apiBase() { return window.location.origin + API_PREFIX; }
+
+// Calls one procedure: resolves the output's own value, rejects with the door's error message when it answered one.
+async function rpc(path, input) {
+  var response = await fetch(apiBase() + '/' + path, {
+    method: 'POST',
+    headers: { 'content-type': 'application/json', authorization: 'Bearer ' + token },
+    body: JSON.stringify({ json: input === undefined ? {} : input }),
+  });
+  var envelope = await response.json().catch(function () { return {}; });
+  if (!response.ok) {
+    var message = envelope && envelope.json && envelope.json.message ? envelope.json.message : ('HTTP ' + response.status);
+    var error = new Error(message);
+    error.status = response.status;
+    throw error;
+  }
+  return envelope.json;
+}
+
+// Parses every complete SSE frame out of the buffered text, returning the frames and the unparsed remainder. Comment frames (the door's keepalive opens with one) carry no event name and are dropped.
+function parseSseFrames(buffer) {
+  var frames = [];
+  var rest = buffer;
+  for (;;) {
+    var boundary = rest.indexOf('\\n\\n');
+    if (boundary === -1) { break; }
+    var raw = rest.slice(0, boundary);
+    rest = rest.slice(boundary + 2);
+    var frame = { event: 'message', id: '', data: '' };
+    var lines = raw.split('\\n');
+    for (var i = 0; i < lines.length; i++) {
+      var line = lines[i];
+      if (line === '' || line.charAt(0) === ':') { continue; }
+      var colon = line.indexOf(':');
+      var field = colon === -1 ? line : line.slice(0, colon);
+      var value = colon === -1 ? '' : line.slice(colon + 1);
+      if (value.charAt(0) === ' ') { value = value.slice(1); }
+      if (field === 'event') { frame.event = value; }
+      if (field === 'id') { frame.id = value; }
+      if (field === 'data') { frame.data += (frame.data === '' ? '' : '\\n') + value; }
+    }
+    if (frame.data !== '') { frames.push(frame); }
+  }
+  return { frames: frames, rest: rest };
+}
+
+// Whether one source-tagged event continues the per-source sequence the tracker holds: the count of events the stream dropped when it does not, zero when it does. The tracker keeps the high-water mark, so a number the door re-sends after a reconnect is a duplicate, not a step back, and never reports a negative gap. The backbone holds no replay, so a gap is reported, never hidden.
+function sequenceGap(tracker, event) {
+  var previous = tracker[event.source];
+  if (event.sequence > (previous === undefined ? 0 : previous)) { tracker[event.source] = event.sequence; }
+  if (previous === undefined || event.sequence <= previous) { return 0; }
+  return event.sequence - previous - 1;
+}
+
+function shortId(id) { return id.length > 14 ? id.slice(0, 8) + '..' + id.slice(-4) : id; }
+
+// A bounded sketch of any payload, the feed's fallback rendering: one JSON line, cut with a marker rather than silently.
+function sketch(value, cap) {
+  var text;
+  try { text = JSON.stringify(value); } catch (e) { text = String(value); }
+  if (text === undefined) { text = 'undefined'; }
+  return text.length > cap ? text.slice(0, cap) + '...' : text;
+}
+
+// The headline text of one Remote Control stream event: the assistant and user payloads that carry a content array of text blocks render as their prose, everything else as its type plus a sketch.
+function rcLine(event) {
+  var envelope = event.envelope;
+  var payload = envelope.payload;
+  var headline = '';
+  if (payload !== undefined && payload !== null && typeof payload === 'object' && Array.isArray(payload.content)) {
+    var parts = [];
+    for (var i = 0; i < payload.content.length; i++) {
+      var block = payload.content[i];
+      if (block !== null && typeof block === 'object' && block.type === 'text' && typeof block.text === 'string') { parts.push(block.text); }
+    }
+    if (parts.length > 0) { headline = parts.join(' '); }
+  }
+  if (headline === '') {
+    headline = envelope.event_type;
+    if (payload !== undefined) { headline += '  ' + sketch(payload, 240); }
+  }
+  return new Date().toLocaleTimeString() + '  ' + shortId(event.session) + '  ' + envelope.event_type + '  ' + headline;
+}
+
+function el(tag, className, text) {
+  var node = document.createElement(tag);
+  if (className) { node.className = className; }
+  if (text !== undefined) { node.textContent = text; }
+  return node;
+}
+
+var ui = null;
+
+function renderEvent(event, gap) {
+  if (ui === null) { return; }
+  var list = ui.eventList;
+  if (gap > 0) {
+    list.appendChild(el('div', 'event gap', 'dropped events: ' + String(gap) + ' on source ' + event.source + ' (the stream holds no replay)'));
+  }
+  var line;
+  if (event.source === 'rc') {
+    line = rcLine(event.payload);
+  } else {
+    line = new Date().toLocaleTimeString() + '  [' + event.source + ']  ' + sketch(event.payload, 240);
+  }
+  list.appendChild(el('div', 'event', line));
+  while (list.childElementCount > 500) { list.removeChild(list.firstChild); }
+  list.scrollTop = list.scrollHeight;
+}
+
+function renderSessions(statuses) {
+  if (ui === null) { return; }
+  var list = ui.sessionList;
+  list.textContent = '';
+  if (statuses.length === 0) {
+    list.appendChild(el('div', 'event dim', 'no Remote Control sessions observed'));
+    return;
+  }
+  for (var i = 0; i < statuses.length; i++) {
+    var status = statuses[i];
+    var worker = status.workerState === undefined ? 'worker unknown' : 'worker ' + status.workerState.value;
+    var row = el('div', 'session' + (status.id === ui.selected ? ' selected' : ''));
+    row.appendChild(el('div', null, shortId(status.id)));
+    row.appendChild(el('div', 'dim', worker + (status.pending.length === 0 ? '' : ', ' + String(status.pending.length) + ' pending') + ', seen ' + new Date(status.lastSeenAt).toLocaleTimeString()));
+    row.addEventListener('click', selectSession(status.id));
+    list.appendChild(row);
+  }
+}
+
+function selectSession(id) {
+  return function () {
+    if (ui === null) { return; }
+    ui.selected = ui.selected === id ? null : id;
+    ui.promptTarget.textContent = ui.selected === null ? 'no session selected' : 'to ' + ui.selected;
+    refreshSessions();
+    refreshPending();
+  };
+}
+
+function renderPending(pending) {
+  if (ui === null) { return; }
+  var list = ui.pendingList;
+  list.textContent = '';
+  if (pending.length === 0) {
+    list.appendChild(el('div', 'event dim', 'no control requests awaiting an answer'));
+    return;
+  }
+  for (var i = 0; i < pending.length; i++) {
+    var request = pending[i];
+    var card = el('div', 'card');
+    card.appendChild(el('div', null, request.type + '  ' + (request.summary === '' ? shortId(request.requestId) : request.summary)));
+    card.appendChild(el('div', 'dim', shortId(request.sessionId) + '  ' + shortId(request.requestId) + '  observed ' + new Date(request.observedAt).toLocaleTimeString()));
+    var row = el('div', 'row');
+    var denial = el('input');
+    denial.type = 'text';
+    denial.placeholder = 'denial message (optional)';
+    var approve = el('button', null, 'Approve');
+    var deny = el('button', 'secondary', 'Deny');
+    approve.addEventListener('click', answerRequest(request, true, denial));
+    deny.addEventListener('click', answerRequest(request, false, denial));
+    row.appendChild(denial);
+    row.appendChild(approve);
+    row.appendChild(deny);
+    card.appendChild(row);
+    list.appendChild(card);
+  }
+}
+
+function answerRequest(request, approve, denialInput) {
+  return function () {
+    var input = { session: request.sessionId, request: request.requestId, approve: approve };
+    if (!approve && denialInput.value !== '') { input.text = denialInput.value; }
+    rpc('rc/answer', input).then(function () {
+      renderEvent({ source: 'page', sequence: 0, payload: { note: (approve ? 'approved' : 'denied') + ' ' + request.requestId } }, 0);
+      refreshPending();
+    }, function (error) { window.alert('answer failed: ' + error.message); });
+  };
+}
+
+function sendPrompt() {
+  if (ui === null || ui.selected === null) { window.alert('select a session first'); return; }
+  var text = ui.prompt.value;
+  if (text === '') { return; }
+  ui.send.disabled = true;
+  rpc('rc/send', { session: ui.selected, text: text }).then(function (result) {
+    ui.prompt.value = '';
+    renderEvent({ source: 'page', sequence: 0, payload: { note: 'sent, sequence_num ' + result.sequenceNums.join(', ') } }, 0);
+  }, function (error) { window.alert('send failed: ' + error.message); }).then(function () { ui.send.disabled = false; });
+}
+
+function refreshSessions() {
+  rpc('rc/status', {}).then(function (result) { renderSessions(result.statuses); }, authOrReport('rc/status'));
+}
+
+function refreshPending() {
+  rpc('rc/pending', ui !== null && ui.selected !== null ? { session: ui.selected } : {}).then(function (result) { renderPending(result.pending); }, authOrReport('rc/pending'));
+}
+
+// The one error path every call shares: a 401 means this token is not this generation's, so the page says so and asks for it again; anything else is reported in the feed.
+function authOrReport(what) {
+  return function (error) {
+    if (error.status === 401) {
+      handleUnauthorized();
+      return;
+    }
+    renderEvent({ source: 'page', sequence: 0, payload: { note: what + ' failed: ' + error.message } }, 0);
+  };
+}
+
+function handleUnauthorized() {
+  window.sessionStorage.removeItem(TOKEN_KEY);
+  if (feedAbort !== null) { feedAbort.abort(); }
+  streamState('');
+  showTokenForm('this door refused the token: it names a different door generation, paste the current one');
+}
+
+function streamState(text) { if (ui !== null) { ui.streamState.textContent = text; } }
+
+var feedAbort = null;
+
+// Subscribes to the door's backbone and renders what it yields, reconnecting on any drop. The stream holds no replay, so a reconnect starts at the live head and the per-source sequence numbers surface whatever the gap swallowed.
+async function runFeed() {
+  var tracker = {};
+  for (;;) {
+    if (feedAbort !== null) { feedAbort.abort(); }
+    feedAbort = new AbortController();
+    var filter = document.getElementById('source-filter').value;
+    var input = filter === '' ? {} : { sources: [filter] };
+    try {
+      streamState('stream: connecting');
+      var response = await fetch(apiBase() + '/events/subscribe', {
+        method: 'POST',
+        headers: { 'content-type': 'application/json', authorization: 'Bearer ' + token },
+        body: JSON.stringify({ json: input }),
+        signal: feedAbort.signal,
+      });
+      if (response.status === 401) { handleUnauthorized(); return; }
+      if (!response.ok || response.body === null) { throw new Error('HTTP ' + String(response.status)); }
+      streamState('stream: live');
+      var reader = response.body.getReader();
+      var decoder = new TextDecoder();
+      var buffer = '';
+      for (;;) {
+        var chunk = await reader.read();
+        if (chunk.done) { break; }
+        buffer += decoder.decode(chunk.value, { stream: true });
+        var parsed = parseSseFrames(buffer);
+        buffer = parsed.rest;
+        for (var i = 0; i < parsed.frames.length; i++) {
+          var frame = parsed.frames[i];
+          if (frame.event !== 'message') { continue; }
+          var event;
+          try { event = JSON.parse(frame.data).json; } catch (e) { continue; }
+          if (event === undefined || event.source === undefined) { continue; }
+          renderEvent(event, sequenceGap(tracker, event));
+        }
+      }
+    } catch (error) {
+      if (feedAbort !== null && feedAbort.signal.aborted) { return; }
+    }
+    streamState('stream: dropped, reconnecting');
+    await new Promise(function (resolve) { window.setTimeout(resolve, 1000); });
+  }
+}
+
+function showTokenForm(message) {
+  if (feedAbort !== null) { feedAbort.abort(); }
+  if (ui !== null) { ui.main.classList.add('hidden'); }
+  var form = document.getElementById('token-form');
+  form.classList.remove('hidden');
+  document.getElementById('token-error').textContent = message === undefined ? '' : message;
+  document.getElementById('token-input').focus();
+}
+
+function startPage(heldToken) {
+  token = heldToken;
+  ui = {
+    main: document.getElementById('main'),
+    eventList: document.getElementById('event-list'),
+    sessionList: document.getElementById('session-list'),
+    pendingList: document.getElementById('pending-list'),
+    prompt: document.getElementById('prompt'),
+    promptTarget: document.getElementById('prompt-target'),
+    send: document.getElementById('send'),
+    streamState: document.getElementById('stream-state'),
+    selected: null,
+  };
+  document.getElementById('token-form').classList.add('hidden');
+  ui.main.classList.remove('hidden');
+  document.getElementById('refresh').addEventListener('click', function () { refreshSessions(); refreshPending(); });
+  document.getElementById('send').addEventListener('click', sendPrompt);
+  document.getElementById('source-filter').addEventListener('change', function () { runFeed(); });
+  ui.prompt.addEventListener('keydown', function (event) {
+    if (event.key === 'Enter' && (event.metaKey || event.ctrlKey)) { sendPrompt(); }
+  });
+  refreshSessions();
+  refreshPending();
+  window.setInterval(function () { refreshSessions(); refreshPending(); }, 4000);
+  runFeed();
+  document.getElementById('door-state').textContent = 'connected';
+}
+
+function boot() {
+  var held = null;
+  var query = new URLSearchParams(window.location.search);
+  var fromQuery = query.get('token');
+  if (fromQuery !== null && fromQuery !== '') {
+    window.sessionStorage.setItem(TOKEN_KEY, fromQuery);
+    // The token leaves the address bar the moment the page holds it, so a refresh or a shared screen shows the clean URL; sessionStorage keeps the tab working.
+    window.history.replaceState(null, '', window.location.pathname);
+    held = fromQuery;
+  } else {
+    held = window.sessionStorage.getItem(TOKEN_KEY);
+  }
+  document.getElementById('token-save').addEventListener('click', function () {
+    var value = document.getElementById('token-input').value.trim();
+    if (value === '') { return; }
+    window.sessionStorage.setItem(TOKEN_KEY, value);
+    startPage(value);
+  });
+  document.getElementById('token-input').addEventListener('keydown', function (event) {
+    if (event.key === 'Enter') { document.getElementById('token-save').click(); }
+  });
+  if (held !== null && held !== '') { startPage(held); }
+}
+
+if (typeof document !== 'undefined' && document.getElementById('event-list') !== null) {
+  window.addEventListener('DOMContentLoaded', boot);
+}
+`;
+var RC_CLIENT_PAGE_HTML = `<!doctype html>
+<html lang="en">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1">
+<title>agent-shim Remote Control</title>
+<style>
+  :root { color-scheme: dark; }
+  * { box-sizing: border-box; }
+  body { margin: 0; background: #101418; color: #d7dde3; font: 14px/1.45 ui-monospace, Menlo, Consolas, monospace; }
+  header { display: flex; gap: 12px; align-items: baseline; padding: 10px 16px; background: #171d24; border-bottom: 1px solid #2a333d; }
+  header h1 { font-size: 15px; margin: 0; font-weight: 600; }
+  header .state { color: #8b98a5; }
+  main { display: flex; gap: 1px; background: #2a333d; min-height: calc(100vh - 39px); }
+  section { background: #101418; padding: 12px 16px; overflow-y: auto; }
+  #sessions { flex: 0 0 320px; border-right: 1px solid #2a333d; }
+  #right { flex: 1; display: flex; flex-direction: column; min-width: 0; }
+  #feed { flex: 1; }
+  #controls { border-top: 1px solid #2a333d; }
+  h2 { font-size: 12px; text-transform: uppercase; letter-spacing: 0.08em; color: #8b98a5; margin: 8px 0 8px; font-weight: 600; }
+  .session { padding: 6px 8px; border: 1px solid transparent; border-radius: 4px; cursor: pointer; white-space: nowrap; overflow: hidden; text-overflow: ellipsis; }
+  .session:hover { background: #171d24; }
+  .session.selected { border-color: #3d6ea5; background: #17222e; }
+  .session .dim { color: #8b98a5; }
+  .event { padding: 2px 0; white-space: pre-wrap; word-break: break-word; }
+  .event .dim { color: #8b98a5; }
+  .event.gap { color: #d29922; }
+  .event.error { color: #e5534b; }
+  textarea, input[type=text], select { background: #171d24; color: #d7dde3; border: 1px solid #2a333d; border-radius: 4px; padding: 6px 8px; font: inherit; width: 100%; }
+  textarea { resize: vertical; min-height: 44px; }
+  button { background: #1f4a7a; color: #d7dde3; border: 1px solid #3d6ea5; border-radius: 4px; padding: 5px 12px; font: inherit; cursor: pointer; }
+  button.secondary { background: #2a333d; border-color: #3a444f; }
+  button:disabled { opacity: 0.5; cursor: default; }
+  .row { display: flex; gap: 8px; margin: 6px 0; align-items: center; }
+  .card { border: 1px solid #3d6ea5; border-radius: 4px; padding: 8px; margin: 6px 0; background: #17222e; }
+  .card .dim { color: #8b98a5; }
+  #token-form { max-width: 480px; margin: 48px auto; }
+  #token-form p { color: #8b98a5; }
+  .hidden { display: none !important; }
+</style>
+</head>
+<body data-agent-shim-rc-client>
+<header>
+  <h1>agent-shim Remote Control</h1>
+  <span class="state" id="door-state">connecting</span>
+  <span class="state" id="stream-state"></span>
+</header>
+<div id="token-form">
+  <h2>This door's control token</h2>
+  <p>The page is served behind the door's per-generation control token. Paste this door generation's token (the owner-only value the door writes beside its state) to use the page; it stays in this tab only.</p>
+  <div class="row"><input type="text" id="token-input" placeholder="control token" autocomplete="off"><button id="token-save">Use</button></div>
+  <p id="token-error" class="event error"></p>
+</div>
+<main class="hidden" id="main">
+  <section id="sessions">
+    <h2>Sessions <button class="secondary" id="refresh">Refresh</button></h2>
+    <div id="session-list"></div>
+  </section>
+  <section id="right">
+    <div id="feed">
+      <h2>Feed <select id="source-filter"><option value="">all sources</option><option value="rc">Remote Control only</option></select></h2>
+      <div id="event-list"></div>
+    </div>
+    <div id="controls">
+      <h2>Pending approvals</h2>
+      <div id="pending-list"></div>
+      <h2>Send a prompt</h2>
+      <div class="row"><textarea id="prompt" placeholder="Prompt for the selected session"></textarea></div>
+      <div class="row"><span class="dim" id="prompt-target">no session selected</span><span style="flex:1"></span><button id="send">Send</button></div>
+    </div>
+  </section>
+</main>
+<script>
+${RC_CLIENT_PAGE_SCRIPT}
+</script>
+</body>
+</html>
+`;
+function pageTokenOf(request7, url2) {
+  const presented = request7.headers.authorization;
+  const bearerPrefix = "bearer ".length;
+  const header = typeof presented === "string" && presented.slice(0, bearerPrefix).toLowerCase() === "bearer " ? presented.slice(bearerPrefix) : void 0;
+  const query = url2.searchParams.get("token") ?? void 0;
+  return header ?? query;
+}
+function serveRcClientPage(expectedToken, request7, response) {
+  const url2 = new URL(request7.url ?? "/", "https://door.invalid");
+  if (url2.pathname !== RC_CLIENT_PATH && url2.pathname !== `${RC_CLIENT_PATH}/`) {
+    response.writeHead(HTTP_STATUS.notFound, { "Content-Type": "text/plain" });
+    response.end("no such page under the door's client prefix");
+    return;
   }
-  return isRecord6(parsed) ? parsed : void 0;
-}
-function readRcSelfHostRecord(fs20, frontdoorDir) {
-  const parsed = readJsonObject(fs20, import_node_path35.default.join(frontdoorDir, RC_SELF_HOST_RECORD_DIR, RC_SELF_HOST_RECORD_FILE));
-  if (parsed === void 0) {
-    return void 0;
+  if (request7.method !== "GET" && request7.method !== "HEAD") {
+    response.writeHead(HTTP_STATUS.methodNotAllowed, { Allow: "GET, HEAD", "Content-Type": "text/plain" });
+    response.end("the door's web client page is read-only");
+    return;
   }
-  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;
+  const token = pageTokenOf(request7, url2);
+  if (token === void 0 || !isLiveCapability(token, [expectedToken])) {
+    response.writeHead(HTTP_STATUS.unauthorized, { "Content-Type": "application/json" });
+    response.end(JSON.stringify({ error: "the door's web client demands this generation's control token, as a Bearer credential or the token query parameter" }));
+    return;
   }
-  return { accessToken, refreshToken, organizationUuid, accountUuid };
+  response.writeHead(HTTP_STATUS.ok, {
+    "Content-Type": "text/html; charset=utf-8",
+    "Cache-Control": "no-store",
+    "Referrer-Policy": "no-referrer",
+    "Content-Security-Policy": "default-src 'none'; script-src 'unsafe-inline'; style-src 'unsafe-inline'; connect-src 'self'"
+  });
+  response.end(request7.method === "HEAD" ? void 0 : RC_CLIENT_PAGE_HTML);
 }
-function mintRcSelfHostCredential(deps) {
-  if (!isIdentityName(deps.identity)) {
-    throw new Error(`"${deps.identity}" is not a valid identity name.`);
-  }
-  const identityDir = import_node_path35.default.join(deps.identitiesDir, deps.identity);
-  const credentialsFile = import_node_path35.default.join(identityDir, CREDENTIALS_FILE);
-  const claudeJsonFile = import_node_path35.default.join(identityDir, CLAUDE_JSON2);
-  const recordDir = import_node_path35.default.join(deps.frontdoorDir, RC_SELF_HOST_RECORD_DIR);
-  const recordFile = import_node_path35.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_path35.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 = (value2) => isRecord6(value2) ? value2 : {};
-  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
-    },
-    cachedGrowthBookFeatures: {
-      ...existingBlock(claudeJson.cachedGrowthBookFeatures),
-      tengu_ccr_bridge: true,
-      tengu_bridge_repl_v2: true,
-      tengu_bridge_repl_v2_cse_shim_enabled: true
+function createRcClientPage(expectedToken) {
+  return {
+    pathPrefix: RC_CLIENT_PATH,
+    handle: async (request7, response) => {
+      serveRcClientPage(expectedToken, request7, response);
+      await Promise.resolve();
+      return { matched: 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/rcStream.ts
@@ -75643,7 +76252,6 @@ function appendLog(paths, line) {
   import_node_fs13.default.appendFileSync(paths.frontdoorLogPath, `${(/* @__PURE__ */ new Date()).toISOString()} ${line}
 `);
 }
-var MINTED_TOKEN_RANDOM_BYTES = 32;
 function rcObservingResolver(resolve, tracker, hub) {
   return async (request7) => {
     const resolution = await resolve(request7);
@@ -75675,8 +76283,8 @@ function realFrontDoorSupervisorPorts(paths) {
   };
   const rcSelfHostSurface = rcSelfHost ? createRcSelfHostSurface({
     now: () => Date.now(),
-    newUuid: import_node_crypto14.randomUUID,
-    randomToken: () => (0, import_node_crypto14.randomBytes)(MINTED_TOKEN_RANDOM_BYTES).toString("base64url"),
+    newUuid: import_node_crypto15.randomUUID,
+    randomToken: () => (0, import_node_crypto15.randomBytes)(MINTED_TOKEN_RANDOM_BYTES).toString("base64url"),
     credentialRecord: () => readRcSelfHostRecord(realFarmFs, paths.frontdoorDir),
     webFetch: realRcWebFetch({ allowPrivate: rcWebFetchAllowsPrivateFromEnv(process.env) }),
     log
@@ -75695,7 +76303,7 @@ function realFrontDoorSupervisorPorts(paths) {
     saveSequenceNum: rcCredentialStore.writeCursor,
     dial: rcSelfHost ? lateRcStreamDial(rcSelfHostDialTarget) : realRcStreamDial(),
     fanout: rcFanout,
-    newClientId: import_node_crypto14.randomUUID,
+    newClientId: import_node_crypto15.randomUUID,
     backoffMs: RC_STREAM_BACKOFF_MS,
     sleep: async (ms) => {
       await new Promise((resolve) => {
@@ -75706,7 +76314,7 @@ function realFrontDoorSupervisorPorts(paths) {
       appendLog(paths, `frontdoor ${String(process.pid)}: ${line}`);
     }
   });
-  const rcControlToken = (0, import_node_crypto14.randomUUID)();
+  const rcControlToken = (0, import_node_crypto15.randomUUID)();
   const resolveRoute = rcObservingResolver(
     createProviderRouteResolver({
       fs: realFsPort,
@@ -75746,8 +76354,8 @@ function realFrontDoorSupervisorPorts(paths) {
     now: () => Date.now(),
     headroomSocket: () => headroomSocketTarget(realFarmFs, realHeadroomSocketTrust, paths),
     // The per-generation capability the direct listener demands: held only in this process's memory, so a loopback process that discovers the direct port still cannot use it.
-    hopSecret: (0, import_node_crypto14.randomUUID)(),
-    custody: createCredentialCustody(() => (0, import_node_crypto14.randomUUID)()),
+    hopSecret: (0, import_node_crypto15.randomUUID)(),
+    custody: createCredentialCustody(() => (0, import_node_crypto15.randomUUID)()),
     log
   });
   const onListenerError = (name) => (error62) => {
@@ -75768,12 +76376,22 @@ function realFrontDoorSupervisorPorts(paths) {
     startProviderListener: async (preferredPort) => {
       const authority = loadCa();
       const rcDial = rcSelfHost ? lateRcEventDial(rcSelfHostDialTarget) : realRcEventDial();
-      const rcInject = async (sessionId, text2) => await injectRcUserMessage({ credentialOf: rcTracker.credentialOf, noteSequenceNums: rcTracker.noteSequenceNums, dial: rcDial, newUuid: import_node_crypto14.randomUUID }, sessionId, text2);
+      const rcInject = async (sessionId, text2) => await injectRcUserMessage({ credentialOf: rcTracker.credentialOf, noteSequenceNums: rcTracker.noteSequenceNums, dial: rcDial, newUuid: import_node_crypto15.randomUUID }, sessionId, text2);
       const rcAnswer = async (sessionId, requestId, decision) => await answerRcControlRequest({ credentialOf: rcTracker.credentialOf, pendingOf: (id) => rcTracker.pendingOf(id), completePending: rcTracker.completePending, noteSequenceNums: rcTracker.noteSequenceNums, dial: rcDial }, sessionId, requestId, decision);
-      const rcControlRequestDeps = { credentialOf: rcTracker.credentialOf, noteSequenceNums: rcTracker.noteSequenceNums, dial: rcDial, newUuid: import_node_crypto14.randomUUID };
+      const rcControlRequestDeps = { credentialOf: rcTracker.credentialOf, noteSequenceNums: rcTracker.noteSequenceNums, dial: rcDial, newUuid: import_node_crypto15.randomUUID };
       const rcInterrupt = async (sessionId) => await interruptRcSession(rcControlRequestDeps, sessionId);
       const rcSetModel = async (sessionId, model) => await setRcSessionModel(rcControlRequestDeps, sessionId, model);
       const rcSetPermissionMode = async (sessionId, mode) => await setRcSessionPermissionMode(rcControlRequestDeps, sessionId, mode);
+      const rcEndSession = async (sessionId, reason) => await endRcSession(rcControlRequestDeps, sessionId, reason);
+      const rcGetUsage = async (sessionId, skipBehaviors) => await getRcSessionUsage(rcControlRequestDeps, sessionId, skipBehaviors);
+      const rcGetContextUsage = async (sessionId, detail) => await getRcSessionContextUsage(rcControlRequestDeps, sessionId, detail);
+      const rcReadFile = async (sessionId, filePath, options) => await readRcSessionFile(rcControlRequestDeps, sessionId, filePath, options);
+      const rcFileSuggestions = async (sessionId, query) => await suggestRcSessionFiles(rcControlRequestDeps, sessionId, query);
+      const rcKeepAlive = async (sessionId) => await sendRcKeepAlive(rcControlRequestDeps, sessionId);
+      const rcMcpStatus = async (sessionId) => await getRcSessionMcpStatus(rcControlRequestDeps, sessionId);
+      const rcMcpReconnect = async (sessionId, serverName) => await reconnectRcSessionMcpServer(rcControlRequestDeps, sessionId, serverName);
+      const rcMcpAuthenticate = async (sessionId, serverName, redirectUri) => await authenticateRcSessionMcpServer(rcControlRequestDeps, sessionId, serverName, redirectUri);
+      const rcMcpOAuthCallbackUrl = async (sessionId, serverName, callbackUrl) => await submitRcSessionMcpOAuthCallbackUrl(rcControlRequestDeps, sessionId, serverName, callbackUrl);
       const controlDeps = {
         usageSnapshots: () => listUsageSnapshots(realFarmFs, paths.usageSnapshotsDir),
         usageSnapshotOf: (identity) => readUsageSnapshot(realFarmFs, paths.usageSnapshotsDir, identity),
@@ -75791,7 +76409,7 @@ function realFrontDoorSupervisorPorts(paths) {
         },
         log,
         mintLeaf(authority, LOOPBACK_LEAF_NAMES, /* @__PURE__ */ new Date()),
-        createRcControlHandler({ expectedToken: rcControlToken, list: rcTracker.list, statusOf: rcTracker.statusOf, pendingOf: rcTracker.pendingOf, inject: rcInject, answer: rcAnswer, interrupt: rcInterrupt, setModel: rcSetModel, setPermissionMode: rcSetPermissionMode }),
+        createRcControlHandler({ expectedToken: rcControlToken, list: rcTracker.list, statusOf: rcTracker.statusOf, pendingOf: rcTracker.pendingOf, inject: rcInject, answer: rcAnswer, interrupt: rcInterrupt, setModel: rcSetModel, setPermissionMode: rcSetPermissionMode, endSession: rcEndSession, getUsage: rcGetUsage, getContextUsage: rcGetContextUsage, readFile: rcReadFile, fileSuggestions: rcFileSuggestions, keepAlive: rcKeepAlive, mcpStatus: rcMcpStatus, mcpReconnect: rcMcpReconnect, mcpAuthenticate: rcMcpAuthenticate, mcpOAuthCallbackUrl: rcMcpOAuthCallbackUrl }),
         [
           createDoorApiNodeHandler({
             expectedToken: rcControlToken,
@@ -75803,6 +76421,16 @@ function realFrontDoorSupervisorPorts(paths) {
             interrupt: rcInterrupt,
             setModel: rcSetModel,
             setPermissionMode: rcSetPermissionMode,
+            endSession: rcEndSession,
+            getUsage: rcGetUsage,
+            getContextUsage: rcGetContextUsage,
+            readFile: rcReadFile,
+            fileSuggestions: rcFileSuggestions,
+            keepAlive: rcKeepAlive,
+            mcpStatus: rcMcpStatus,
+            mcpReconnect: rcMcpReconnect,
+            mcpAuthenticate: rcMcpAuthenticate,
+            mcpOAuthCallbackUrl: rcMcpOAuthCallbackUrl,
             fanout: rcFanout,
             ...controlDeps,
             events: doorEvents
@@ -75822,7 +76450,7 @@ function realFrontDoorSupervisorPorts(paths) {
     },
     startConnectListener: async (preferredPort) => {
       const wantedTransparentPort = process.env.AGENT_SHIM_TRANSPARENT_SURFACE === void 0 ? void 0 : Number(process.env.AGENT_SHIM_TRANSPARENT_SURFACE);
-      const transparentCapability = wantedTransparentPort === void 0 || Number.isNaN(wantedTransparentPort) ? void 0 : (0, import_node_crypto14.randomUUID)();
+      const transparentCapability = wantedTransparentPort === void 0 || Number.isNaN(wantedTransparentPort) ? void 0 : (0, import_node_crypto15.randomUUID)();
       if (transparentCapability !== void 0) {
         writeFrontDoorSession(realFarmFs, paths.frontdoorSessionsDir, { pid: process.pid, startedAt: Date.now(), token: transparentCapability });
       }
@@ -75866,123 +76494,41 @@ function realFrontDoorSupervisorPorts(paths) {
           upstreamFor: (host) => ({ host, port: HTTPS_PORT, tls: true }),
           isLiveCapability: isLiveToken,
           ...wantedTransparentPort === void 0 || Number.isNaN(wantedTransparentPort) ? {} : { transparentPort: wantedTransparentPort, ...transparentCapability === void 0 ? {} : { transparentCapability } },
-          limits: CONNECT_LIMITS,
-          ...capture === void 0 ? {} : { capture }
-        },
-        realConnectEffects(),
-        preferredPort
-      );
-      transparentPort = server.transparentPort;
-      return {
-        port: server.port,
-        close: async () => {
-          rcSelfHostSurface?.close();
-          await server.close();
-        }
-      };
-    },
-    startDirectListener: async (preferredPort) => {
-      const server = createFrontDoorServer(async (request7) => {
-        await serveRouted(request7, pipelines.direct);
-      }, log);
-      const handle = await listenFrontDoor(server, {
-        ...preferredPort === void 0 ? {} : { preferredPort },
-        onBound: (port) => {
-          directPort = port;
-        },
-        onError: onListenerError("direct")
-      });
-      return { port: handle.port, close: handle.close };
-    },
-    closeRcStreamHub: rcHub.close,
-    // The launch lifecycle publisher over the same backbone the typed API serves: the tick's registry facts go in here, and the door's own register, prune and end moments come out as source-tagged events.
-    observeLaunchRegistry: createLaunchEventPublisher(doorEvents, () => Date.now()).observe,
-    log: (line) => {
-      appendLog(paths, line);
-    }
-  };
-}
-function formatRcSessionList(sessions) {
-  if (sessions.length === 0) {
-    return ["no Remote Control sessions observed"];
-  }
-  return sessions.map((session) => `${session.id}  created ${new Date(session.createdAt).toISOString()}  last seen ${new Date(session.lastSeenAt).toISOString()}`);
-}
-function formatRcSessionStatus(statuses) {
-  if (statuses.length === 0) {
-    return ["no Remote Control sessions observed"];
-  }
-  const lines = [];
-  for (const status of statuses) {
-    lines.push(`${status.id}  created ${new Date(status.createdAt).toISOString()}  last seen ${new Date(status.lastSeenAt).toISOString()}`);
-    const worker = status.workerState === void 0 && status.workerIdleSeconds === void 0 ? "not observed" : [
-      status.workerState === void 0 ? "state unknown" : `state ${status.workerState.value} since ${new Date(status.workerState.observedAt).toISOString()}`,
-      status.workerIdleSeconds === void 0 ? "idle unknown" : `idle ${String(status.workerIdleSeconds.value)} s as of ${new Date(status.workerIdleSeconds.observedAt).toISOString()}`
-    ].join(", ");
-    lines.push(`  worker: ${worker}`);
-    if (status.pending.length === 0) {
-      lines.push("  pending: none");
-    } else {
-      lines.push("  pending:");
-      for (const pending of status.pending) {
-        lines.push(...formatRcPendingList([pending]).map((line) => `    ${line}`));
-      }
-    }
-  }
-  return lines;
-}
-function formatRcPendingList(pending) {
-  if (pending.length === 0) {
-    return ["no pending control requests observed"];
-  }
-  return pending.map((request7) => `${request7.sessionId}  ${request7.requestId}  ${request7.type}${request7.summary === "" ? "" : `  ${request7.summary}`}  observed ${new Date(request7.observedAt).toISOString()}`);
-}
-function eventExcerpt(text2) {
-  return text2.length <= RC_PENDING_SUMMARY_EXCERPT_CHARS ? text2 : `${text2.slice(0, RC_PENDING_SUMMARY_EXCERPT_CHARS)}...`;
-}
-function formatRcStreamEvent(event) {
-  const { envelope } = event;
-  const sketch = envelope.payload === void 0 ? "" : `  ${eventExcerpt(JSON.stringify(envelope.payload))}`;
-  return `${event.session}  ${envelope.event_type}  sequence_num ${String(envelope.sequence_num)}  source ${envelope.source}${sketch}`;
-}
-function formatRcSelfHostMint(result) {
-  return [
-    `identity:       ${result.identity} (organisation ${result.organizationUuid})`,
-    `credential:     ${result.credentialsFile}${result.replaced ? " (replacing this door's previous mint)" : ""}`,
-    `account block:  ${result.claudeJsonFile} (oauthAccount and the feature-cache seed merged in)`,
-    `door record:    ${result.recordFile} (the copy the door's served surface authenticates against)`,
-    "next:           start the door with AGENT_SHIM_FRONTDOOR_RC_SELF_HOST=1 and its transparent surface pointed at the interception port, then launch this identity and switch Remote Control on; no claude.ai login is involved"
-  ];
-}
-function frontDoorRcControlFromState(fsPort, paths) {
-  const state = readFrontDoorState(fsPort, paths.frontdoorStateFile);
-  if (state?.port === void 0) {
-    throw new Error("the front door is not serving: Remote Control sessions are observed only while it runs, so start a session through the door first");
-  }
-  const ca = fsPort.readFileUtf8(paths.frontdoorCaCertFile);
-  if (ca === void 0) {
-    throw new Error(`the front door's CA certificate is missing at ${paths.frontdoorCaCertFile}, so its control listener cannot be authenticated`);
-  }
-  const token = fsPort.readFileUtf8(paths.frontdoorControlTokenFile)?.trim();
-  if (token === void 0 || token === "") {
-    throw new Error(`the serving front door's control token is missing at ${paths.frontdoorControlTokenFile}`);
-  }
-  return frontDoorRcControl(realRcControlTransport(state.port, ca), token);
-}
-function frontDoorRcApiFromState(fsPort, paths) {
-  const state = readFrontDoorState(fsPort, paths.frontdoorStateFile);
-  if (state?.port === void 0) {
-    throw new Error("the front door is not serving: Remote Control sessions are observed only while it runs, so start a session through the door first");
-  }
-  const ca = fsPort.readFileUtf8(paths.frontdoorCaCertFile);
-  if (ca === void 0) {
-    throw new Error(`the front door's CA certificate is missing at ${paths.frontdoorCaCertFile}, so its typed API cannot be authenticated`);
-  }
-  const token = fsPort.readFileUtf8(paths.frontdoorControlTokenFile)?.trim();
-  if (token === void 0 || token === "") {
-    throw new Error(`the serving front door's control token is missing at ${paths.frontdoorControlTokenFile}`);
-  }
-  return frontDoorRcApiClient(state.port, ca, token);
+          limits: CONNECT_LIMITS,
+          ...capture === void 0 ? {} : { capture }
+        },
+        realConnectEffects(),
+        preferredPort
+      );
+      transparentPort = server.transparentPort;
+      return {
+        port: server.port,
+        close: async () => {
+          rcSelfHostSurface?.close();
+          await server.close();
+        }
+      };
+    },
+    startDirectListener: async (preferredPort) => {
+      const server = createFrontDoorServer(async (request7) => {
+        await serveRouted(request7, pipelines.direct);
+      }, log);
+      const handle = await listenFrontDoor(server, {
+        ...preferredPort === void 0 ? {} : { preferredPort },
+        onBound: (port) => {
+          directPort = port;
+        },
+        onError: onListenerError("direct")
+      });
+      return { port: handle.port, close: handle.close };
+    },
+    closeRcStreamHub: rcHub.close,
+    // The launch lifecycle publisher over the same backbone the typed API serves: the tick's registry facts go in here, and the door's own register, prune and end moments come out as source-tagged events.
+    observeLaunchRegistry: createLaunchEventPublisher(doorEvents, () => Date.now()).observe,
+    log: (line) => {
+      appendLog(paths, line);
+    }
+  };
 }
 function registerFrontDoorCommand(program2, deps) {
   const { paths } = deps;
@@ -76002,186 +76548,7 @@ function registerFrontDoorCommand(program2, deps) {
     }),
     ["agent-shim frontdoor status", "agent-shim frontdoor status --json"]
   );
-  const rc = withExamples(
-    frontdoor.command("rc").description("Observe the Remote Control sessions passing through the front door, watch the stream their attached client receives, send a prompt into one, answer its pending control requests, and steer one with the client half's own control requests (interrupt, model, permission mode)."),
-    ["agent-shim frontdoor rc list", "agent-shim frontdoor rc pending"]
-  );
-  withExamples(
-    rc.command("list").description("List the Remote Control sessions the front door has observed, with when each was created and last seen. Read-only.").option("--json", "Print the sessions as JSON.").action(async (options) => {
-      const sessions = await frontDoorRcControlFromState(realFarmFs, paths).listSessions();
-      if (options.json === true) {
-        printJson({ sessions });
-        return;
-      }
-      for (const line of formatRcSessionList(sessions)) {
-        console.log(line);
-      }
-    }),
-    ["agent-shim frontdoor rc list", "agent-shim frontdoor rc list --json"]
-  );
-  withExamples(
-    rc.command("status").description("Report each observed Remote Control session's worker state and idle from its latest observed heartbeat and registration, with its pending control requests. Read-only.").argument("[session]", "One cse_ session id, as `frontdoor rc list` shows it; every observed session when omitted.").option("--json", "Print the statuses as JSON.").action(async (session, options) => {
-      const statuses = await frontDoorRcControlFromState(realFarmFs, paths).statusOf(session);
-      if (options.json === true) {
-        printJson({ statuses });
-        return;
-      }
-      for (const line of formatRcSessionStatus(statuses)) {
-        console.log(line);
-      }
-    }),
-    ["agent-shim frontdoor rc status", "agent-shim frontdoor rc status cse_00000000-0000-4000-8000-000000000000 --json"]
-  );
-  withExamples(
-    rc.command("pending").description("List the control requests (tool and plan approvals above all) the front door has observed and that are still awaiting an answer. Read-only.").argument("[session]", "One cse_ session id, as `frontdoor rc list` shows it; every observed session when omitted.").option("--json", "Print the pending requests as JSON.").action(async (session, options) => {
-      const pending = await frontDoorRcControlFromState(realFarmFs, paths).pendingOf(session);
-      if (options.json === true) {
-        printJson({ pending });
-        return;
-      }
-      for (const line of formatRcPendingList(pending)) {
-        console.log(line);
-      }
-    }),
-    ["agent-shim frontdoor rc pending", "agent-shim frontdoor rc pending --json"]
-  );
-  withExamples(
-    rc.command("send").description("Send a text prompt into one observed Remote Control session, arriving as a message from an attached client would.").requiredOption("--session <id>", "The cse_ session id, as `frontdoor rc list` shows it.").requiredOption("--text <text>", "The prompt text to deliver.").option("--json", "Print the delivery result as JSON.").action(async (options) => {
-      const result = await frontDoorRcControlFromState(realFarmFs, paths).sendPrompt(options.session, options.text);
-      if (!result.ok) {
-        throw new Error(result.message);
-      }
-      if (options.json === true) {
-        printJson({ session: options.session, sequenceNums: result.sequenceNums });
-        return;
-      }
-      console.log(`sent to ${options.session}: sequence_num ${result.sequenceNums.join(", ")}`);
-    }),
-    ['agent-shim frontdoor rc send --session cse_00000000-0000-4000-8000-000000000000 --text "run the tests"']
-  );
-  withExamples(
-    rc.command("answer").description("Answer one pending control request on an observed session, approving or denying it as an attached client's approval would.").requiredOption("--session <id>", "The cse_ session id, as `frontdoor rc list` shows it.").requiredOption("--request <id>", "The control request's id, as `frontdoor rc pending` shows it.").option("--approve", "Approve the request.").option("--deny", "Deny the request.").option("--text <text>", "The denial message the worker sees; applies to --deny only.").option("--json", "Print the delivery result as JSON.").action(async (options) => {
-      if (options.approve === options.deny) {
-        throw new UsageError("answer exactly one way: pass --approve or --deny, not both and not neither");
-      }
-      if (options.approve === true && options.text !== void 0) {
-        throw new UsageError("--text is the denial message; an approval carries no text (the protocol's allow result has no message field)");
-      }
-      const result = await frontDoorRcControlFromState(realFarmFs, paths).answerRequest(options.session, options.request, { approve: options.approve === true, message: options.deny === true ? options.text : void 0 });
-      if (!result.ok) {
-        throw new Error(result.message);
-      }
-      if (options.json === true) {
-        printJson({ session: options.session, request: options.request, sequenceNums: result.sequenceNums });
-        return;
-      }
-      console.log(`${options.approve === true ? "approved" : "denied"} ${options.request} on ${options.session}: sequence_num ${result.sequenceNums.join(", ")}`);
-    }),
-    [
-      "agent-shim frontdoor rc answer --session cse_00000000-0000-4000-8000-000000000000 --request req_00000000-0000-4000-8000-000000000000 --approve",
-      'agent-shim frontdoor rc answer --session cse_00000000-0000-4000-8000-000000000000 --request req_00000000-0000-4000-8000-000000000000 --deny --text "not today"'
-    ]
-  );
-  withExamples(
-    rc.command("interrupt").description("Interrupt one observed Remote Control session's running turn, as an attached client's stop button would. Queued commands survive the interrupt.").requiredOption("--session <id>", "The cse_ session id, as `frontdoor rc list` shows it.").option("--json", "Print the delivery result as JSON.").action(async (options) => {
-      const result = await frontDoorRcControlFromState(realFarmFs, paths).interruptSession(options.session);
-      if (!result.ok) {
-        throw new Error(result.message);
-      }
-      if (options.json === true) {
-        printJson({ session: options.session, sequenceNums: result.sequenceNums });
-        return;
-      }
-      console.log(`interrupted ${options.session}: sequence_num ${result.sequenceNums.join(", ")}`);
-    }),
-    ["agent-shim frontdoor rc interrupt --session cse_00000000-0000-4000-8000-000000000000"]
-  );
-  withExamples(
-    rc.command("set-model").description("Set the model one observed Remote Control session's subsequent turns use, as an attached client's model picker would.").requiredOption("--session <id>", "The cse_ session id, as `frontdoor rc list` shows it.").requiredOption("--model <model>", "The model id to switch the session to.").option("--json", "Print the delivery result as JSON.").action(async (options) => {
-      const result = await frontDoorRcControlFromState(realFarmFs, paths).setModel(options.session, options.model);
-      if (!result.ok) {
-        throw new Error(result.message);
-      }
-      if (options.json === true) {
-        printJson({ session: options.session, model: options.model, sequenceNums: result.sequenceNums });
-        return;
-      }
-      console.log(`set ${options.session} to model ${options.model}: sequence_num ${result.sequenceNums.join(", ")}`);
-    }),
-    ["agent-shim frontdoor rc set-model --session cse_00000000-0000-4000-8000-000000000000 --model claude-opus-5-5"]
-  );
-  withExamples(
-    rc.command("set-permission-mode").description("Set one observed Remote Control session's permission mode, as an attached client's mode switcher would.").requiredOption("--session <id>", "The cse_ session id, as `frontdoor rc list` shows it.").requiredOption("--mode <mode>", `The permission mode to set; one of the SDK's own modes (${RC_PERMISSION_MODES.join(", ")}).`).option("--json", "Print the delivery result as JSON.").action(async (options) => {
-      if (!isRcPermissionMode(options.mode)) {
-        throw new UsageError(`--mode must be one of the SDK's own permission modes (${RC_PERMISSION_MODES.join(", ")}), not "${options.mode}"`);
-      }
-      const result = await frontDoorRcControlFromState(realFarmFs, paths).setPermissionMode(options.session, options.mode);
-      if (!result.ok) {
-        throw new Error(result.message);
-      }
-      if (options.json === true) {
-        printJson({ session: options.session, mode: options.mode, sequenceNums: result.sequenceNums });
-        return;
-      }
-      console.log(`set ${options.session} to permission mode ${options.mode}: sequence_num ${result.sequenceNums.join(", ")}`);
-    }),
-    [
-      "agent-shim frontdoor rc set-permission-mode --session cse_00000000-0000-4000-8000-000000000000 --mode plan",
-      "agent-shim frontdoor rc set-permission-mode --session cse_00000000-0000-4000-8000-000000000000 --mode acceptEdits"
-    ]
-  );
-  withExamples(
-    rc.command("watch").description("Print the observed sessions' client read stream events as they arrive, the approvals the door's held stream receives above all, until Ctrl-C leaves. Read-only.").argument("[session]", "One cse_ session id, as `frontdoor rc list` shows it; every observed session when omitted.").option("--json", "Print each event as one JSON line as it arrives.").action(async (session, options) => {
-      const client = frontDoorRcApiFromState(realFarmFs, paths);
-      const leave = new AbortController();
-      const onInterrupt = () => {
-        leave.abort();
-      };
-      process.once("SIGINT", onInterrupt);
-      try {
-        for await (const event of await client.rc.subscribe(session === void 0 ? {} : { session }, { signal: leave.signal })) {
-          if (options.json === true) {
-            console.log(JSON.stringify(event));
-            continue;
-          }
-          console.log(formatRcStreamEvent(event));
-        }
-      } catch (error62) {
-        if (!leave.signal.aborted) {
-          throw error62;
-        }
-      } finally {
-        process.off("SIGINT", onInterrupt);
-      }
-    }),
-    ["agent-shim frontdoor rc watch", "agent-shim frontdoor rc watch cse_00000000-0000-4000-8000-000000000000 --json"]
-  );
-  const selfhost = withExamples(
-    rc.command("selfhost").description("Mint the local credential behind the door's self-hosted Remote Control surface: the opt-in mode (AGENT_SHIM_FRONTDOOR_RC_SELF_HOST=1 in the door's environment) where the door serves the CCR surface itself and a session activates Remote Control with no Anthropic credential anywhere."),
-    ["agent-shim frontdoor rc selfhost mint rig"]
-  );
-  withExamples(
-    selfhost.command("mint").description("Mint the local OAuth credential, account block and feature-cache seed one identity needs to activate Remote Control against the door's own served surface, and record the door-side copy the surface authenticates against. Refuses to replace a real claude.ai login unless --force. Never prints a token.").argument("<identity>", "The identity to mint into, as `agent-shim identity list` names it.").option("--force", "Replace an existing OAuth credential this door did not mint.").option("--json", "Print the mint result as JSON.").action((identity, options) => {
-      const result = mintRcSelfHostCredential({
-        fs: realFarmFs,
-        identitiesDir: paths.identitiesDir,
-        frontdoorDir: paths.frontdoorDir,
-        identity,
-        newUuid: import_node_crypto14.randomUUID,
-        randomToken: () => (0, import_node_crypto14.randomBytes)(MINTED_TOKEN_RANDOM_BYTES).toString("base64url"),
-        force: options.force === true,
-        now: () => Date.now()
-      });
-      if (options.json === true) {
-        printJson(result);
-        return;
-      }
-      for (const line of formatRcSelfHostMint(result)) {
-        console.log(line);
-      }
-    }),
-    ["agent-shim frontdoor rc selfhost mint rig", "agent-shim frontdoor rc selfhost mint rig --force"]
-  );
+  registerRcCommand(frontdoor, paths);
   program2.command("__frontdoor-supervisor", { hidden: true }).description("Internal: serve the front-door routing listeners. Started by the launcher; never run by hand.").allowUnknownOption().action(async () => {
     const idleShutdownMinutes = readGlobalConfig(paths)?.frontdoor?.idleShutdownMinutes ?? FRONTDOOR_DEFAULT_IDLE_SHUTDOWN_MINUTES;
     process.on("SIGTERM", () => {
@@ -76673,7 +77040,7 @@ var import_node_child_process6 = require("node:child_process");
 var import_node_fs15 = __toESM(require("node:fs"), 1);
 
 // src/frontdoor/ensure.ts
-var import_node_crypto15 = require("node:crypto");
+var import_node_crypto16 = require("node:crypto");
 var FRONTDOOR_START_TIMEOUT_MS = 3e4;
 var FRONTDOOR_LAUNCHER_POLL_MS = 100;
 var FrontDoorStartError = class extends CliError {
@@ -76707,7 +77074,7 @@ function ensureFrontDoor(params) {
           continue;
         }
         if (verdict.ok) {
-          const token = (0, import_node_crypto15.randomUUID)();
+          const token = (0, import_node_crypto16.randomUUID)();
           writeFrontDoorSession(ports.fs, paths.frontdoorSessionsDir, { pid: params.launcherPid, startedAt: ports.now(), token });
           return { port: state.port, connectPort: state.connectPort, token };
         }
@@ -76811,7 +77178,7 @@ function probeFrontDoorSync(port, caPem) {
 }
 
 // src/frontdoor/trust.ts
-var import_node_crypto16 = require("node:crypto");
+var import_node_crypto17 = require("node:crypto");
 var import_node_path38 = __toESM(require("node:path"), 1);
 var BUNDLE_NAME_HEX_DIGITS = 16;
 function resolveTrustBundle(params) {
@@ -76834,7 +77201,7 @@ function resolveTrustBundle(params) {
   }
   const combined = `${inheritedPem.trimEnd()}
 ${caPem}`;
-  const bundle = import_node_path38.default.join(bundlesDir, `${(0, import_node_crypto16.createHash)("sha256").update(combined).digest("hex").slice(0, BUNDLE_NAME_HEX_DIGITS)}.pem`);
+  const bundle = import_node_path38.default.join(bundlesDir, `${(0, import_node_crypto17.createHash)("sha256").update(combined).digest("hex").slice(0, BUNDLE_NAME_HEX_DIGITS)}.pem`);
   if (!fs20.exists(bundle)) {
     fs20.mkdirp(bundlesDir);
     fs20.writeFileAtomic(bundle, combined);
@@ -77539,12 +77906,13 @@ function registerRunCommand(program2, handler) {
 }
 
 // src/update/commands.ts
+var import_node_child_process7 = require("node:child_process");
 var import_node_fs17 = __toESM(require("node:fs"), 1);
 var import_node_os7 = __toESM(require("node:os"), 1);
 var import_node_path41 = __toESM(require("node:path"), 1);
 
 // src/update/update.ts
-var import_node_crypto17 = require("node:crypto");
+var import_node_crypto18 = require("node:crypto");
 var import_node_path40 = __toESM(require("node:path"), 1);
 var LATEST_RELEASE_URL = "https://github.com/ExaDev/agent-shim/releases/latest";
 var DOWNLOAD_BASE_URL = "https://github.com/ExaDev/agent-shim/releases/latest/download";
@@ -77699,11 +78067,11 @@ async function downloadAndInstall(ports, asset, target) {
       throw new UpdateDownloadError(`the downloaded files for ${asset} are missing from ${tempDir}`);
     }
     const expected = expectedSha256(sidecar);
-    const actual = (0, import_node_crypto17.createHash)("sha256").update(downloaded).digest("hex");
+    const actual = (0, import_node_crypto18.createHash)("sha256").update(downloaded).digest("hex");
     if (expected === void 0 || expected !== actual) {
       throw new UpdateDownloadError(`checksum mismatch for ${asset} (expected ${expected ?? "(none)"}, got ${actual})`);
     }
-    const tempBinary = import_node_path40.default.join(import_node_path40.default.dirname(target), `.${import_node_path40.default.basename(target)}.${String(process.pid)}.${(0, import_node_crypto17.randomUUID)()}.tmp`);
+    const tempBinary = import_node_path40.default.join(import_node_path40.default.dirname(target), `.${import_node_path40.default.basename(target)}.${String(process.pid)}.${(0, import_node_crypto18.randomUUID)()}.tmp`);
     ports.fs.writeFileBytes(tempBinary, downloaded);
     try {
       ports.fs.chmod(tempBinary, EXECUTABLE_MODE);
@@ -77874,11 +78242,41 @@ function formatUpdateReport(report) {
       return report.action;
   }
 }
+function setUpdateMode(paths, mode) {
+  const existing = readGlobalConfig(paths);
+  applyPatch(paths.globalConfigFile, GlobalConfigSchema, { update: { ...existing?.update, mode } }, { defaults: {} });
+}
+function realLaunchUpdatePort(paths) {
+  return {
+    effectiveUrl: realUpdatePorts.http.effectiveUrl,
+    readStamp: (filePath) => realUpdatePorts.fs.readFileUtf8(filePath),
+    writeStamp: (filePath, contents) => {
+      writeTextAtomic(filePath, contents);
+    },
+    now: () => Date.now(),
+    spawnDetached: (args) => {
+      const invocation = selfInvocation(args);
+      const child = (0, import_node_child_process7.spawn)(invocation.command, invocation.args, { detached: true, stdio: "ignore", env: { ...process.env, AGENT_SHIM_HOME: paths.root } });
+      child.unref();
+    },
+    writeErr: (line) => {
+      console.error(line);
+    }
+  };
+}
 function registerUpdateCommand(program2, deps, ports = realUpdatePorts) {
   withExamples(
     program2.command("update").description(
-      "Download the newest release binary and install it over the running one. An installation that belongs to a package manager (Homebrew, npm, Scoop) names its channel and its upgrade command instead of updating in place."
-    ).option("--check", "Only report whether a newer release exists; download and change nothing.").option("--json", "Print the result as JSON.").action(async (options) => {
+      "Download the newest release binary and install it over the running one. An installation that belongs to a package manager (Homebrew, npm, Scoop) names its channel and its upgrade command instead of updating in place. With --mode, set the launch-time update mode in the global config instead of updating now."
+    ).option("--check", "Only report whether a newer release exists; download and change nothing.").addOption(new Option("--mode <mode>", "Set what a launch does about a newer release (off: nothing; notify: print one line; auto: also apply it in the background) in the global config, then exit.").choices(UPDATE_MODES)).option("--json", "Print the result as JSON.").action(async (options) => {
+      const mode = options.mode;
+      if (mode !== void 0) {
+        setUpdateMode(deps.paths, mode);
+        reportMutation(options.json, { action: "updated", kind: "update", name: "mode", value: { mode } }, () => {
+          console.log(`update mode set to ${mode}`);
+        });
+        return;
+      }
       const report = await runSelfUpdate(ports, {
         currentVersion: package_default.version,
         platform: process.platform,
@@ -77894,7 +78292,7 @@ function registerUpdateCommand(program2, deps, ports = realUpdatePorts) {
       }
       console.log(formatUpdateReport(report));
     }),
-    ["agent-shim update", "agent-shim update --check", "agent-shim update --json"]
+    ["agent-shim update", "agent-shim update --check", "agent-shim update --mode auto", "agent-shim update --json"]
   );
 }
 
@@ -78182,10 +78580,10 @@ function buildProgram(deps) {
 
 // src/launchWiring.ts
 var import_node_os9 = __toESM(require("node:os"), 1);
-var import_node_crypto19 = require("node:crypto");
+var import_node_crypto20 = require("node:crypto");
 
 // src/launcher.ts
-var import_node_crypto18 = require("node:crypto");
+var import_node_crypto19 = require("node:crypto");
 var import_node_path43 = __toESM(require("node:path"), 1);
 
 // src/launcher/cliOverride.ts
@@ -78479,6 +78877,68 @@ function spawnClaude(params) {
   return params.proc.exit(exitCodeFor(result));
 }
 
+// src/update/launchHook.ts
+var UPDATE_CHECK_COOLDOWN_MS = 864e5;
+function resolveUpdateMode(globalConfig2) {
+  return globalConfig2?.update?.mode ?? "off";
+}
+function updateCheckDue(contents, nowMs, cooldownMs = UPDATE_CHECK_COOLDOWN_MS) {
+  if (contents === void 0) {
+    return true;
+  }
+  const checkedAt = Date.parse(contents.trim());
+  if (Number.isNaN(checkedAt)) {
+    return true;
+  }
+  const age = nowMs - checkedAt;
+  return age < 0 || age >= cooldownMs;
+}
+var NOOP_HANDLE = { markChildStarted: () => void 0 };
+function updateNotifyLine(currentVersion, latest) {
+  return `agent-shim: update available: ${currentVersion} -> ${latest} (run \`agent-shim update\` to install it)`;
+}
+function runLaunchUpdateCheck(params) {
+  const { mode, checkPath, currentVersion, port } = params;
+  if (mode === "off" || port === void 0) {
+    return NOOP_HANDLE;
+  }
+  let childStarted = false;
+  try {
+    if (!updateCheckDue(port.readStamp(checkPath), port.now())) {
+      return NOOP_HANDLE;
+    }
+    port.writeStamp(checkPath, new Date(port.now()).toISOString());
+  } catch {
+    return NOOP_HANDLE;
+  }
+  const answer = (url2) => {
+    try {
+      const latest = releaseTagFromUrl(url2);
+      if (latest === void 0 || compareVersions3(latest, currentVersion) <= 0) {
+        return;
+      }
+      if (mode === "auto") {
+        port.spawnDetached(["update"]);
+      }
+      if (!childStarted) {
+        port.writeErr(updateNotifyLine(currentVersion, latest));
+      }
+    } catch {
+    }
+  };
+  port.effectiveUrl(LATEST_RELEASE_URL).then(
+    (url2) => {
+      answer(url2);
+    },
+    () => void 0
+  );
+  return {
+    markChildStarted: () => {
+      childStarted = true;
+    }
+  };
+}
+
 // src/launcher.ts
 function resolveIdentityCredential(identity, credential, env, port) {
   if (port === void 0) {
@@ -78644,6 +79104,12 @@ function prepareLaunch(params) {
   log.info(
     `agent-shim: identity ${identityDecision.name ?? "(none)"} (${identityDecision.source}${poolExplanation === void 0 ? "" : `, ${poolExplanation}`}), config profile ${configProfileDecision.name ?? "(none)"} (${configProfileDecision.source})` + (resolvedProvider === void 0 ? "" : `, provider ${resolvedProvider.name} (credential ${resolvedProvider.credential.target} from ${describeSource(resolvedProvider.credential.source)})`) + (identityCredential === void 0 ? "" : `, identity credential ${identityCredential.target} from ${describeSource(identityCredential.source)}`)
   );
+  const updateCheck = runLaunchUpdateCheck({
+    mode: params.updateMode ?? "off",
+    checkPath: import_node_path43.default.join(paths.root, "update.check"),
+    currentVersion: package_default.version,
+    port: params.update
+  });
   let cascadeLaunch;
   if (farmContext !== void 0) {
     const { farm: resyncFarmRuntime, identity: resyncIdentity, cascade } = farmContext;
@@ -78741,7 +79207,7 @@ function prepareLaunch(params) {
     ...identityCredential === void 0 ? {} : { identityCredential },
     ...frontDoor === void 0 ? {} : { frontdoor: frontDoor },
     ...headroom === void 0 ? {} : { headroom },
-    sessionId: (0, import_node_crypto18.randomUUID)()
+    sessionId: (0, import_node_crypto19.randomUUID)()
   });
   const releases = [...headroom === void 0 || headroomPort === void 0 ? [] : [headroomPort.release], ...frontDoorRelease === void 0 ? [] : [frontDoorRelease]];
   const release = () => {
@@ -78749,11 +79215,12 @@ function prepareLaunch(params) {
       registered();
     }
   };
-  return { bin: discovered.path, args: finalArgv, env: finalEnv, release };
+  return { bin: discovered.path, args: finalArgv, env: finalEnv, release, markChildStarted: updateCheck.markChildStarted };
 }
 function runLauncher(params) {
   const plan = prepareLaunch(params);
   try {
+    plan.markChildStarted();
     spawnClaude({ bin: plan.bin, args: plan.args, env: plan.env, spawn: params.spawn, proc: params.proc, beforeExit: plan.release });
   } finally {
     plan.release();
@@ -78768,6 +79235,7 @@ function buildFarmRuntime(paths, cwd) {
   const loaded = loadCascadeInput({ paths, home, cwd, read });
   const selections = readDirectorySelections(loaded);
   const git = resolveGitBranch(realRunPort, cwd);
+  const updateMode = resolveUpdateMode(loaded.globalConfig);
   return {
     runtime: {
       fs: realFarmFs,
@@ -78786,14 +79254,15 @@ function buildFarmRuntime(paths, cwd) {
         ...cliOverride === void 0 ? {} : { cliOverride }
       }).input,
       now: () => Date.now(),
-      uniqueSuffix: `${String(process.pid)}.${(0, import_node_crypto19.randomUUID)()}`,
+      uniqueSuffix: `${String(process.pid)}.${(0, import_node_crypto20.randomUUID)()}`,
       // Zombie-aware on purpose: a previous launcher that crashed out of a resync without releasing the lock may sit unreaped, still answering signal 0 as alive, and must read as a dead holder so this launch takes the lock over instead of timing out.
       lock: { pid: process.pid, isRunning: realIsProcessRunning, sleep: realSleepSync }
     },
     ...selections.identity === void 0 ? {} : { directoryIdentity: selections.identity },
     ...selections.configProfile === void 0 ? {} : { directoryConfigProfile: selections.configProfile },
     ...loaded.globalConfig?.defaultConfigProfile === void 0 ? {} : { globalDefaultConfigProfile: loaded.globalConfig.defaultConfigProfile },
-    ...loaded.globalConfig?.pools === void 0 ? {} : { pools: loaded.globalConfig.pools }
+    ...loaded.globalConfig?.pools === void 0 ? {} : { pools: loaded.globalConfig.pools },
+    ...updateMode === "off" ? {} : { updateMode }
   };
 }
 function realClaudeBinaryResolver(paths) {
@@ -78815,6 +79284,7 @@ function realPrepareLaunchParams(paths, options) {
     ...farm.directoryConfigProfile === void 0 ? {} : { directoryRuleConfigProfile: farm.directoryConfigProfile },
     ...farm.globalDefaultConfigProfile === void 0 ? {} : { globalDefaultConfigProfile: farm.globalDefaultConfigProfile },
     ...farm.pools === void 0 ? {} : { pools: farm.pools },
+    ...farm.updateMode === void 0 ? {} : { updateMode: farm.updateMode },
     ...options.allowMissingConfigProfile === void 0 ? {} : { allowMissingConfigProfile: options.allowMissingConfigProfile }
   };
 }
@@ -78918,6 +79388,8 @@ async function runClaude(argvOverride) {
       farm,
       allowMissingConfigProfile
     }),
+    // Wired here rather than in realPrepareLaunchParams because the port re-invokes this very binary: correct for the agent-shim command line, wrong for a library host whose own executable is not agent-shim.
+    update: realLaunchUpdatePort(paths),
     spawn: realSpawnPort
   });
 }