agent-shim 8.23.0 → 8.25.0

package/dist/types/index.d.ts

@@ -1775,7 +1775,7 @@ interface FrontDoorRoute {
 }
 
 /**
- * Remote Control session tracking and the client-half writes the front door performs: the record of the `cse_` sessions whose traffic crosses its terminated API-host session, the prompt injected into one, the answer delivered to one of its pending control requests, and the client-originated control requests sent into one (interrupt, set_model, set_permission_mode).
+ * Remote Control session tracking: the record of the `cse_` sessions whose traffic crosses the door's terminated API-host session, and of the control requests awaiting an answer inside them. The client-half writes themselves (the prompt inject, the `control_response` answer, and every client-originated control request) live in `rcWrites.ts`, built on the observed credential this tracker holds.
  *
  * The tracker is observational: the door already terminates the API host's TLS, so it sees the CLI's own `POST /v1/code/sessions` (whose answer carries the new session's `cse_` id) and every recurring `/v1/code/sessions/...` call (heartbeat, presence), each carrying the session's Authorization bearer and the protocol headers a client-half replay needs. Per session the tracker retains the latest of each, because those calls recur and the freshest value is the live one. It also reads the request bodies of the exchanges whose payloads matter: the worker's event batches (whose `control_request` payloads, `can_use_tool` above all, are the approvals awaiting an answer), the worker heartbeats (whose bodies carry `idle_seconds`), the worker registration (whose body carries the worker state), and the client-half event writes (whose `control_response` payloads complete a pending request). Everything is held in this process's memory only: nothing here is written to a log, to the capture, or to disk, and the summary the control surface lists never includes the credential. The capture's existing redaction is untouched; a capture and this tracker observe the same exchanges through entirely separate paths.
  *
@@ -1892,6 +1892,16 @@ declare function observingRoutedRoute(route: FrontDoorRoute, tracker: RcSessionT
 }): FrontDoorRoute;
 /** Adapts the tracker's exchange observer to the passthrough forwarding's observer shape, so the connect test world (which forwards rather than routes) observes through the same tracker. */
 declare function rcObserverAsPassthrough(observer: RcExchangeObserver): PassthroughObserver;
+
+/**
+ * The Remote Control client-half writes: the payload builders, the write engine and one typed operation per control verb the door can send into an observed session, every one an event write to `/v1/code/sessions/{id}/events` over the door's interception-proof dials, authenticated by the observed bearer and protocol headers the tracker (`rcSessions.ts`) holds.
+ *
+ * Every request-shaped write goes through one envelope builder (`buildRcControlRequestPayload`) so the family cannot drift apart in shape, and one delivery engine (`deliverRcClientPayload`, module-local) so the two credential guards, the dial and the sequence-cursor advance exist exactly once. The fields each subtype carries are the SDK's own (`@anthropic-ai/claude-agent-sdk` `sdk.d.ts`) where it declares the subtype, and the CLI bundle's own request builders where it does not (`mcp_authenticate`, `mcp_oauth_callback_url`), each named in its builder's doc comment.
+ *
+ * A write that carried a `control_request` returns the request id it minted, because the worker's `control_response` echoes exactly that id on the stream the door already fans out: a consumer that wants the answer matches it there, and the id is surfaced by the result since only the door ever knew it.
+ *
+ * Two writes stand outside the events path: the teleport marker, whose channel is the session's teleport-events path (the one write the family addresses elsewhere, and the one the CLI only ever reads), and the read receipt, which is not a payload write at all but the mark_read endpoint's own small body, built here so every surface the door serves it from posts the same shape.
+ */
 /**
  * Builds the user-message payload event for one injected prompt: the Agent SDK stream-json `user` message shape (`type`, `uuid`, `session_id`, `parent_tool_use_id`, `message` with a `user` role), the same envelope a claude.ai client sends as a turn. The content is the plain string form, which is the shape validated end to end against the real API by the third-party client survey that settled this protocol.
  */
@@ -1912,11 +1922,18 @@ interface RcDialAnswer {
 /** The one network effect a client-half write performs, injected so the pure logic runs against fakes: POST the write body to the session's events endpoint. Production dials the real API host over the door's interception-proof agent; tests redirect to a local stand-in. */
 interface RcEventDial {
     readonly writeEvents: (sessionId: string, headers: Readonly<Record<string, string>>, body: string) => Promise<RcDialAnswer>;
+    /**
+     * Posts one write to the session's teleport-events path instead of its events path: the write half of the channel the CLI only ever reads (`GET /teleport-events`, the teleport-to-local hydration's page source, verified in the 2.1.289 bundle, which contains no POST sender for it at all). The door's own client half is the one sender this surface has, so this method exists for `teleportRcSession` alone.
+     */
+    readonly writeTeleportEvents: (sessionId: string, headers: Readonly<Record<string, string>>, body: string) => Promise<RcDialAnswer>;
 }
-/** What one client-half write produced: the sequence numbers the real service assigned, or a verbose failure message ready to show a user. */
+/**
+ * What one client-half write produced: the sequence numbers the real service assigned, or a verbose failure message ready to show a user. A write that carried a `control_request` also names the request id it minted, because the worker's `control_response` echoes exactly that id on the stream: a consumer that wants the answer matches it there, and the id is surfaced here since only the door ever knew it.
+ */
 type RcEventWriteResult = {
     readonly ok: true;
     readonly sequenceNums: readonly number[];
+    readonly requestId?: string;
 } | {
     readonly ok: false;
     readonly message: string;
@@ -1959,7 +1976,11 @@ type RcPermissionMode = (typeof RC_PERMISSION_MODES)[number];
 /** Whether a value is one of the SDK's own permission modes, the narrowing the CLI and the control route apply to untrusted input. */
 declare function isRcPermissionMode(value: unknown): value is RcPermissionMode;
 /**
- * Builds the `control_request` payload event for one interrupt: the SDK's request envelope (`SDKControlRequest`: `type`, `request_id`, `request`), carrying the `interrupt` subtype's own shape (`subtype` alone; its optional `cancel_queued` is absent, which the SDK reads as false, so queued commands survive the interrupt exactly as a plain stop button's would). The request id is the caller's minted uuid, the id the worker's `control_response` echoes.
+ * Builds the `control_request` payload event's envelope around one subtype's own request shape: the SDK's own envelope (`SDKControlRequest`: `type`, `request_id`, `request`), with the request id the caller minted, the id the worker's `control_response` echoes. Every client-originated control request below goes through this one envelope so the family cannot drift apart in shape.
+ */
+declare function buildRcControlRequestPayload(requestId: string, request: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Builds the `control_request` payload event for one interrupt: the SDK's request envelope, carrying the `interrupt` subtype's own shape (`subtype` alone; its optional `cancel_queued` is absent, which the SDK reads as false, so queued commands survive the interrupt exactly as a plain stop button's would). The request id is the caller's minted uuid, the id the worker's `control_response` echoes.
  */
 declare function buildRcInterruptPayload(requestId: string): Record<string, unknown>;
 /**
@@ -1970,6 +1991,69 @@ declare function buildRcSetModelPayload(requestId: string, model: string): Recor
  * Builds the `control_request` payload event for one permission-mode change: the SDK's request envelope carrying the `set_permission_mode` subtype's own shape, whose one field is the `mode` from the SDK's own `PermissionMode` enum (`RC_PERMISSION_MODES`).
  */
 declare function buildRcSetPermissionModePayload(requestId: string, mode: RcPermissionMode): Record<string, unknown>;
+/**
+ * Builds the `control_request` payload event for one session end: the SDK's request envelope carrying the `end_session` subtype's own shape, whose one field is the optional `reason` string (the CLI's own sender passes `reason: "session_not_found"` and its receiver logs `reason ?? "unspecified"`, both verified in the 2.1.267 bundle; an omitted reason is the protocol's own unnamed form, so the builder omits the field entirely rather than sending an empty string).
+ */
+declare function buildRcEndSessionPayload(requestId: string, reason: string | undefined): Record<string, unknown>;
+/**
+ * Builds the `control_request` payload event for one usage query: the SDK's request envelope carrying the `get_usage` subtype's own shape, whose one field is the optional `skip_behaviors` boolean (the CLI's own client sends the field only when true, so this builder does the same; the SDK documents the field as skipping the local-transcript scan that fills the response's behaviours section).
+ */
+declare function buildRcGetUsagePayload(requestId: string, skipBehaviors: boolean | undefined): Record<string, unknown>;
+/**
+ * The detail levels the SDK's own `get_context_usage` control request accepts: exactly the strings its `detail` field declares (`'summary' | 'full'`), nothing looser. A runtime list as well as a type, because the CLI and the control route both narrow untrusted strings through it before a write is ever attempted.
+ */
+declare const RC_CONTEXT_USAGE_DETAILS: readonly ["summary", "full"];
+/** One detail level the SDK's `get_context_usage` control request accepts. */
+type RcContextUsageDetail = (typeof RC_CONTEXT_USAGE_DETAILS)[number];
+/** Whether a value is one of the SDK's own context-usage detail levels, the narrowing the CLI and the control route apply to untrusted input. */
+declare function isRcContextUsageDetail(value: unknown): value is RcContextUsageDetail;
+/**
+ * Builds the `control_request` payload event for one context-usage query: the SDK's request envelope carrying the `get_context_usage` subtype's own shape, whose one field is the optional `detail` level (`'summary'` or `'full'`, defaulting to `'full'` server-side when omitted, so the builder omits the field rather than restating the default).
+ */
+declare function buildRcGetContextUsagePayload(requestId: string, detail: RcContextUsageDetail | undefined): Record<string, unknown>;
+/**
+ * The encodings the SDK's own `read_file` control request accepts: exactly the strings its `encoding` field declares, nothing looser. A runtime list as well as a type, because the CLI and the control route both narrow untrusted strings through it before a write is ever attempted.
+ */
+declare const RC_READ_FILE_ENCODINGS: readonly ["utf-8", "base64"];
+/** One encoding the SDK's `read_file` control request accepts. */
+type RcReadFileEncoding = (typeof RC_READ_FILE_ENCODINGS)[number];
+/** Whether a value is one of the SDK's own read-file encodings, the narrowing the CLI and the control route apply to untrusted input. */
+declare function isRcReadFileEncoding(value: unknown): value is RcReadFileEncoding;
+/** The optional parts of one read-file request: the byte cap and the encoding the SDK's own fields name. */
+interface RcReadFileOptions {
+    /** The `max_bytes` cap, a positive number of bytes. */
+    readonly maxBytes?: number;
+    /** The `encoding` the answer's `contents` carry; the SDK's own default is `utf-8`. */
+    readonly encoding?: RcReadFileEncoding;
+}
+/**
+ * Builds the `control_request` payload event for one file read: the SDK's request envelope carrying the `read_file` subtype's own shape, whose fields are the required `path` string and the optional `max_bytes` number and `encoding` level (`'utf-8' | 'base64'`), each sent only when the caller named it (the CLI's own client builds exactly this shape, verified in the 2.1.267 bundle).
+ */
+declare function buildRcReadFilePayload(requestId: string, path: string, options: RcReadFileOptions | undefined): Record<string, unknown>;
+/**
+ * Builds the `control_request` payload event for one file-suggestion query: the SDK's request envelope carrying the `file_suggestions` subtype's own shape, whose one required field is the `query` string (the partial path prefix the TUI's at-mention autocomplete fuzzy-matches; the SDK imposes no minimum, so an empty query is sent as the empty prefix it is).
+ */
+declare function buildRcFileSuggestionsPayload(requestId: string, query: string): Record<string, unknown>;
+/**
+ * Builds the `control_request` payload event for one MCP status query: the SDK's request envelope carrying the `mcp_status` subtype's own shape, which declares no fields of its own (the CLI's own client requests it the same way and reads its answer's `mcpServers`).
+ */
+declare function buildRcMcpStatusPayload(requestId: string): Record<string, unknown>;
+/**
+ * Builds the `control_request` payload event for one MCP server reconnect: the SDK's request envelope carrying the `mcp_reconnect` subtype's own shape, whose one field is the `serverName` string (the casing the SDK and the CLI's own client both use for this family, unlike the snake_case the older subtypes carry).
+ */
+declare function buildRcMcpReconnectPayload(requestId: string, serverName: string): Record<string, unknown>;
+/**
+ * Builds the `control_request` payload event for one MCP OAuth handshake start: the SDK's request envelope carrying the `mcp_authenticate` subtype's own shape, whose fields are the `serverName` and the `redirectUri` the server's OAuth flow redirects back to (the exact object the CLI's own `mcpAuthenticate` builds, verified in the 2.1.267 bundle; this subtype is absent from the published SDK types, so the bundle is the field's only source).
+ */
+declare function buildRcMcpAuthenticatePayload(requestId: string, serverName: string, redirectUri: string): Record<string, unknown>;
+/**
+ * Builds the `control_request` payload event for one MCP OAuth callback hand-in: the SDK's request envelope carrying the `mcp_oauth_callback_url` subtype's own shape, whose fields are the `serverName` and the `callbackUrl` the browser landed on (the exact object the CLI's own `mcpSubmitOAuthCallbackUrl` builds, verified in the 2.1.267 bundle; this subtype is absent from the published SDK types, so the bundle is the field's only source).
+ */
+declare function buildRcMcpOAuthCallbackUrlPayload(requestId: string, serverName: string, callbackUrl: string): Record<string, unknown>;
+/**
+ * Builds the liveness payload event on its own, with no request envelope around it: the SDK's own `SDKKeepAliveMessage` is a top-level stream payload (`type` alone, no `request_id`, no `request`), which either side may send at any time and receivers must ignore, so this is the one client-half write that neither expects nor can receive an answer. The CLI's own transports write exactly this object into their event streams, verified in the 2.1.267 bundle.
+ */
+declare function buildRcKeepAlivePayload(): Record<string, unknown>;
 /** Everything one answer needs, injected so the decision logic runs against fakes in unit tests. */
 interface RcAnswerDeps {
     /** Reads the observed credential for a session: the tracker's accessor, in production. */
@@ -1999,17 +2083,65 @@ interface RcControlRequestDeps {
     readonly newUuid: () => string;
 }
 /**
- * Interrupts one observed session's running turn: the same documented client-half write the inject and answer paths perform, carrying the SDK's `control_request` envelope for the `interrupt` subtype, authenticated by the observed bearer and protocol headers. The result is the sequence numbers the real service assigned, or a verbose failure. A dial that cannot reach the API host is reported rather than thrown, so a caller with no exception handling still shows the user exactly what failed.
+ * Interrupts one observed session's running turn: the same documented client-half write the inject and answer paths perform, carrying the SDK's `control_request` envelope for the `interrupt` subtype, authenticated by the observed bearer and protocol headers. The result names the minted request id (the id the worker's `control_response` echoes on the stream) and the sequence numbers the real service assigned, or a verbose failure. A dial that cannot reach the API host is reported rather than thrown, so a caller with no exception handling still shows the user exactly what failed.
  */
 declare function interruptRcSession(deps: RcControlRequestDeps, sessionId: string): Promise<RcEventWriteResult>;
 /**
- * Sets the model one observed session's subsequent turns use: the same documented client-half write the inject and answer paths perform, carrying the SDK's `control_request` envelope for the `set_model` subtype with the model id its own field names. The id is validated only as non-empty, because the SDK's field gives the empty-free forms their own meaning (omitted or null resets to the session default) and this operation sends neither. The result is the sequence numbers the real service assigned, or a verbose failure.
+ * Sets the model one observed session's subsequent turns use: the same documented client-half write the inject and answer paths perform, carrying the SDK's `control_request` envelope for the `set_model` subtype with the model id its own field names. The id is validated only as non-empty, because the SDK's field gives the empty-free forms their own meaning (omitted or null resets to the session default) and this operation sends neither. The result names the minted request id and the sequence numbers the real service assigned, or a verbose failure.
  */
 declare function setRcSessionModel(deps: RcControlRequestDeps, sessionId: string, model: string): Promise<RcEventWriteResult>;
 /**
- * Sets one observed session's permission mode: the same documented client-half write the inject and answer paths perform, carrying the SDK's `control_request` envelope for the `set_permission_mode` subtype with a mode from the SDK's own enum (`RC_PERMISSION_MODES`; the type accepts nothing looser, and the CLI and control route narrow untrusted strings through `isRcPermissionMode` before they ever reach this operation). The result is the sequence numbers the real service assigned, or a verbose failure.
+ * Sets one observed session's permission mode: the same documented client-half write the inject and answer paths perform, carrying the SDK's `control_request` envelope for the `set_permission_mode` subtype with a mode from the SDK's own enum (`RC_PERMISSION_MODES`; the type accepts nothing looser, and the CLI and control route narrow untrusted strings through `isRcPermissionMode` before they ever reach this operation). The result names the minted request id and the sequence numbers the real service assigned, or a verbose failure.
  */
 declare function setRcSessionPermissionMode(deps: RcControlRequestDeps, sessionId: string, mode: RcPermissionMode): Promise<RcEventWriteResult>;
+/**
+ * Ends one observed session: the documented client-half write carrying the SDK's `control_request` envelope for the `end_session` subtype, the request whose receipt makes the worker abort its turn and shut down by its own rules (verified in the CLI's source: its print loop logs `end_session received` and ends the child). The reason is optional and sent only when non-empty, because the receiver reads an absent reason as its own "unspecified" form and an empty string is neither. The result names the minted request id and the sequence numbers the real service assigned, or a verbose failure.
+ */
+declare function endRcSession(deps: RcControlRequestDeps, sessionId: string, reason: string | undefined): Promise<RcEventWriteResult>;
+/**
+ * Asks one observed session's worker for its structured usage: the documented client-half write carrying the SDK's `control_request` envelope for the `get_usage` subtype. The worker's answer (session cost and usage totals plus the plan's rate-limit utilisation) arrives later as the `control_response` echoing the minted request id on the stream the door already fans out, which is why the result names that id; the door invents no usage state of its own.
+ */
+declare function getRcSessionUsage(deps: RcControlRequestDeps, sessionId: string, skipBehaviors: boolean | undefined): Promise<RcEventWriteResult>;
+/**
+ * Asks one observed session's worker for its context-window breakdown: the documented client-half write carrying the SDK's `control_request` envelope for the `get_context_usage` subtype. The worker's answer (the per-category breakdown) arrives later as the `control_response` echoing the minted request id on the stream the door already fans out; the detail level is the SDK's own enum, narrowed by `isRcContextUsageDetail` before this operation is reached.
+ */
+declare function getRcSessionContextUsage(deps: RcControlRequestDeps, sessionId: string, detail: RcContextUsageDetail | undefined): Promise<RcEventWriteResult>;
+/**
+ * Asks one observed session's worker to read one file from the session filesystem: the documented client-half write carrying the SDK's `control_request` envelope for the `read_file` subtype, the request the remote sidebar viewer rides. The path is resolved by the worker against its own cwd and gated by its own read-permission rules; the answer (the contents) arrives later as the `control_response` echoing the minted request id on the stream the door already fans out.
+ */
+declare function readRcSessionFile(deps: RcControlRequestDeps, sessionId: string, path: string, options: RcReadFileOptions | undefined): Promise<RcEventWriteResult>;
+/**
+ * Asks one observed session's worker for its at-mention file suggestions: the documented client-half write carrying the SDK's `control_request` envelope for the `file_suggestions` subtype, the request the TUI's own autocomplete rides, answered with the same fuzzy-matched results. The answer arrives later as the `control_response` echoing the minted request id on the stream the door already fans out; the query may be empty, because the SDK's own field imposes no minimum and an empty prefix is the autocomplete's root listing.
+ */
+declare function suggestRcSessionFiles(deps: RcControlRequestDeps, sessionId: string, query: string): Promise<RcEventWriteResult>;
+/**
+ * Asks one observed session's worker for the status of its MCP server connections: the documented client-half write carrying the SDK's `control_request` envelope for the `mcp_status` subtype, which declares no fields of its own. The answer arrives later as the `control_response` echoing the minted request id on the stream the door already fans out.
+ */
+declare function getRcSessionMcpStatus(deps: RcControlRequestDeps, sessionId: string): Promise<RcEventWriteResult>;
+/**
+ * Asks one observed session's worker to reconnect one MCP server: the documented client-half write carrying the SDK's `control_request` envelope for the `mcp_reconnect` subtype, whose one field is the server name exactly as `mcp_status` reports it. The answer arrives later as the `control_response` echoing the minted request id on the stream the door already fans out.
+ */
+declare function reconnectRcSessionMcpServer(deps: RcControlRequestDeps, sessionId: string, serverName: string): Promise<RcEventWriteResult>;
+/**
+ * Starts one MCP server's OAuth handshake on an observed session: the documented client-half write carrying the `control_request` envelope for the `mcp_authenticate` subtype, whose fields name the server and the redirect URI its OAuth flow redirects back to. The answer arrives later as the `control_response` echoing the minted request id on the stream the door already fans out.
+ */
+declare function authenticateRcSessionMcpServer(deps: RcControlRequestDeps, sessionId: string, serverName: string, redirectUri: string): Promise<RcEventWriteResult>;
+/**
+ * Hands one MCP server's OAuth callback to an observed session's worker: the documented client-half write carrying the `control_request` envelope for the `mcp_oauth_callback_url` subtype, whose fields name the server and the callback URL the browser landed on, completing the handshake `mcp_authenticate` started. The answer arrives later as the `control_response` echoing the minted request id on the stream the door already fans out.
+ */
+declare function submitRcSessionMcpOAuthCallbackUrl(deps: RcControlRequestDeps, sessionId: string, serverName: string, callbackUrl: string): Promise<RcEventWriteResult>;
+/**
+ * Sends one liveness heartbeat into an observed session: the documented client-half write carrying the `keep_alive` payload on its own, with no request envelope, because the SDK declares it a top-level stream message either side may send at any time and receivers must ignore. The minted sequence numbers confirm delivery and nothing else will ever answer, which is the payload's own contract; this write is how a door-driven client keeps its half of the stream warm without saying anything.
+ */
+declare function sendRcKeepAlive(deps: RcControlRequestDeps, sessionId: string): Promise<RcEventWriteResult>;
+/**
+ * Sends one teleport marker into an observed session: the write half of the teleport-events channel, whose read half (`GET /v1/code/sessions/{id}/teleport-events`, paged `{data: [{payload}], next_cursor}` with `x-organization-uuid` and the optional trusted-device header) is the teleport-to-local hydration's page source, verified in the 2.1.289 bundle. The CLI itself never POSTs to the channel (the bundle's only sender is the GET reader); the writer is the cloud UI, whose marker is a user message carrying a sentinel string the local relay anchors on (its own parser demands a line with a uuid and string content), so the payload here is exactly that shape: the SDK user-message envelope carrying the caller's marker text. The result names the sequence numbers the service assigned, or a verbose failure.
+ */
+declare function teleportRcSession(deps: RcControlRequestDeps, sessionId: string, marker: string): Promise<RcEventWriteResult>;
+/**
+ * Builds the read-receipt body the mark_read endpoint takes: `{event_id}` naming one event, or `{}` marking the whole session read, exactly the two shapes the CLI's own `markSessionRead` sender posts (verified in the 2.1.289 bundle: `n ? {event_id: n} : {}`, with no client id in the body at all).
+ */
+declare function buildRcMarkReadBody(eventId: string | undefined): Record<string, unknown>;
 
 /**
  * How long a failed attachment backs off before retrying. Not a fresh number: it is the session's own liveness bound (`RC_IDLE_EXPIRY_MS`, the 45 s stream timeout the tracker's idle expiry already derives from), so an attachment that cannot be re-established retries at exactly the cadence the protocol itself gives up on a quiet session at. Production passes that constant; tests pass small values so a backoff is reached in milliseconds.
@@ -2045,10 +2177,13 @@ interface RcStreamAnswer {
     readonly chunks: AsyncIterable<Uint8Array>;
 }
 /**
- * The one network effect the client read stream performs, injected so the attachment logic runs against fakes: announce a client's presence, and open the read stream. Production dials the real API host over the door's interception-proof agent; tests redirect to a local stand-in. `resume` names the documented resume pair's value: present only when the door has seen events for the session already, it sends `from_sequence_num` as a query parameter and `Last-Event-ID` as a header together.
+ * The one network effect the client read stream performs, injected so the attachment logic runs against fakes: announce a client's presence (a pulse, or the clear that retires it), open the read stream, and send the read receipts a reading client owes for what it read. Production dials the real API host over the door's interception-proof agent; tests redirect to a local stand-in. `resume` names the documented resume pair's value: present only when the door has seen events for the session already, it sends `from_sequence_num` as a query parameter and `Last-Event-ID` as a header together.
  */
 interface RcStreamDial {
-    readonly announcePresence: (sessionId: string, headers: Readonly<Record<string, string>>, clientId: string) => Promise<RcPresenceAnswer>;
+    /** Announces the client: a pulse (`clear` false) while it reads, and the clear (`clear` true) that retires it when the attachment ends for good. The CLI's own presence sender posts exactly this body shape (`{client_id, clear}`, verified in the 2.1.289 bundle, whose teardown path posts `clear: true` and whose pulses are the same call without it). */
+    readonly announcePresence: (sessionId: string, headers: Readonly<Record<string, string>>, clientId: string, clear: boolean) => Promise<RcPresenceAnswer>;
+    /** Sends one read receipt: the mark_read endpoint's own body (`{event_id}`, or `{}` for the whole session), the duty the CLI's own remote-client half performs with the same body (`markSessionRead`, verified in the 2.1.289 bundle). */
+    readonly markRead: (sessionId: string, headers: Readonly<Record<string, string>>, eventId: string | undefined) => Promise<RcPresenceAnswer>;
     readonly openStream: (sessionId: string, headers: Readonly<Record<string, string>>, resume: {
         readonly fromSequenceNum: number;
     } | undefined, signal: AbortSignal) => Promise<RcStreamAnswer>;
@@ -2141,7 +2276,7 @@ declare function realRcStreamDial(target?: RcDialTarget): RcStreamDial;
 declare function realConnectEffects(ports?: SourcePortRange): ConnectEffects;
 
 /**
- * The Remote Control control surface: the small HTTP namespace the serving door answers on its provider listener, next to `/healthz`, through which `agent-shim frontdoor rc` lists the observed sessions, reports each one's status and pending control requests, injects a prompt into one, answers one of its pending requests, and sends its own control requests into one (interrupt, set-model, set-permission-mode).
+ * The Remote Control control surface: the small HTTP namespace the serving door answers on its provider listener, next to `/healthz`, through which `agent-shim frontdoor rc` lists the observed sessions, reports each one's status and pending control requests, injects a prompt into one, answers one of its pending requests, and sends its own control requests into one (interrupt, set-model, set-permission-mode, and the wider client-half verb family: end-session, the usage and context queries, read-file, file-suggestions, keep-alive, and the mcp_* family).
  *
  * This rides the listener `frontdoor status` already knows the door by (its address comes from the same state file, its trust anchor from the same CA path) rather than any second channel. The routes sit under one prefix the routed pipeline never serves, and every request must present the serving generation's control token as a Bearer credential: a fresh random value per door start, written owner-only under the front door's state directory so only this user's CLI can read it, and checked in constant time like every other capability the door accepts. An inject, answer or control request is carried out by the door itself over its interception-proof dials, which is the whole point: the CLI never dials the API host directly, so nothing about the write depends on the caller's own network path.
  */
@@ -2167,6 +2302,28 @@ interface RcControlHandlerDeps {
     readonly setModel: (sessionId: string, model: string) => Promise<RcEventWriteResult>;
     /** The set-permission-mode operation, already wired to the tracker and the door's API-host dial. */
     readonly setPermissionMode: (sessionId: string, mode: RcPermissionMode) => Promise<RcEventWriteResult>;
+    /** The end-session operation, already wired to the tracker and the door's API-host dial. */
+    readonly endSession: (sessionId: string, reason: string | undefined) => Promise<RcEventWriteResult>;
+    /** The get-usage operation, already wired to the tracker and the door's API-host dial. */
+    readonly getUsage: (sessionId: string, skipBehaviors: boolean | undefined) => Promise<RcEventWriteResult>;
+    /** The get-context-usage operation, already wired to the tracker and the door's API-host dial. */
+    readonly getContextUsage: (sessionId: string, detail: RcContextUsageDetail | undefined) => Promise<RcEventWriteResult>;
+    /** The read-file operation, already wired to the tracker and the door's API-host dial. */
+    readonly readFile: (sessionId: string, path: string, options: RcReadFileOptions | undefined) => Promise<RcEventWriteResult>;
+    /** The file-suggestions operation, already wired to the tracker and the door's API-host dial. */
+    readonly fileSuggestions: (sessionId: string, query: string) => Promise<RcEventWriteResult>;
+    /** The keep-alive operation, already wired to the tracker and the door's API-host dial. */
+    readonly keepAlive: (sessionId: string) => Promise<RcEventWriteResult>;
+    /** The mcp-status operation, already wired to the tracker and the door's API-host dial. */
+    readonly mcpStatus: (sessionId: string) => Promise<RcEventWriteResult>;
+    /** The mcp-reconnect operation, already wired to the tracker and the door's API-host dial. */
+    readonly mcpReconnect: (sessionId: string, serverName: string) => Promise<RcEventWriteResult>;
+    /** The mcp-authenticate operation, already wired to the tracker and the door's API-host dial. */
+    readonly mcpAuthenticate: (sessionId: string, serverName: string, redirectUri: string) => Promise<RcEventWriteResult>;
+    /** The mcp-oauth-callback-url operation, already wired to the tracker and the door's API-host dial. */
+    readonly mcpOAuthCallbackUrl: (sessionId: string, serverName: string, callbackUrl: string) => Promise<RcEventWriteResult>;
+    /** The teleport operation, already wired to the tracker and the door's API-host dial. */
+    readonly teleport: (sessionId: string, marker: string) => Promise<RcEventWriteResult>;
 }
 /**
  * Builds the control handler the provider listener serves under `CONTROL_PATH_PREFIX`. Every route demands the generation's control token first, so nothing about the sessions (their ids, their timing, and most of all the prompts and approvals carried into them) is reachable by a process that did not read the owner-only token file.
@@ -2188,7 +2345,7 @@ interface RcControlTransport {
 }
 /** The real transport: HTTPS to the door's provider listener on loopback, trusting only the CA file the door's own state names, so a process merely holding the port cannot answer as the door. */
 declare function realRcControlTransport(port: number, ca: string): RcControlTransport;
-/** The door-facing client the `frontdoor rc` verbs use: the session list, the status and pending reads, the inject and answer operations, and the door's own control requests (interrupt, set-model, set-permission-mode), over the injected transport. */
+/** The door-facing client the `frontdoor rc` verbs use: the session list, the status and pending reads, the inject and answer operations, and the door's own control requests (interrupt, set-model, set-permission-mode, and the wider verb family: end-session, the usage and context queries, read-file, file-suggestions, keep-alive, and the mcp_* family), over the injected transport. */
 interface FrontDoorRcControl {
     /** The observed sessions, oldest-created first. Throws with the door's verbose reason when the list cannot be had. */
     readonly listSessions: () => Promise<readonly RcSessionSummary[]>;
@@ -2200,12 +2357,34 @@ interface FrontDoorRcControl {
     readonly sendPrompt: (sessionId: string, text: string) => Promise<RcEventWriteResult>;
     /** Answers one pending control request, returning the sequence numbers the real service assigned or the verbose failure. */
     readonly answerRequest: (sessionId: string, requestId: string, decision: RcAnswerDecision) => Promise<RcEventWriteResult>;
-    /** Interrupts one session's running turn, returning the sequence numbers the real service assigned or the verbose failure. */
+    /** Interrupts one session's running turn, returning the minted request id and the sequence numbers the real service assigned, or the verbose failure. */
     readonly interruptSession: (sessionId: string) => Promise<RcEventWriteResult>;
-    /** Sets the model one session's subsequent turns use, returning the sequence numbers the real service assigned or the verbose failure. */
+    /** Sets the model one session's subsequent turns use, returning the minted request id and the sequence numbers the real service assigned, or the verbose failure. */
     readonly setModel: (sessionId: string, model: string) => Promise<RcEventWriteResult>;
-    /** Sets one session's permission mode, returning the sequence numbers the real service assigned or the verbose failure. */
+    /** Sets one session's permission mode, returning the minted request id and the sequence numbers the real service assigned, or the verbose failure. */
     readonly setPermissionMode: (sessionId: string, mode: RcPermissionMode) => Promise<RcEventWriteResult>;
+    /** Ends one session, returning the minted request id and the sequence numbers the real service assigned, or the verbose failure. */
+    readonly endSession: (sessionId: string, reason: string | undefined) => Promise<RcEventWriteResult>;
+    /** Asks one session's worker for its structured usage, returning the minted request id (the id its `control_response` answer echoes) and the sequence numbers, or the verbose failure. */
+    readonly getUsage: (sessionId: string, skipBehaviors: boolean | undefined) => Promise<RcEventWriteResult>;
+    /** Asks one session's worker for its context-window breakdown, returning the minted request id and the sequence numbers, or the verbose failure. */
+    readonly getContextUsage: (sessionId: string, detail: RcContextUsageDetail | undefined) => Promise<RcEventWriteResult>;
+    /** Asks one session's worker to read one file, returning the minted request id and the sequence numbers, or the verbose failure. */
+    readonly readFile: (sessionId: string, path: string, options: RcReadFileOptions | undefined) => Promise<RcEventWriteResult>;
+    /** Asks one session's worker for its at-mention file suggestions, returning the minted request id and the sequence numbers, or the verbose failure. */
+    readonly fileSuggestions: (sessionId: string, query: string) => Promise<RcEventWriteResult>;
+    /** Sends one liveness heartbeat into a session, returning the sequence numbers the real service assigned or the verbose failure. */
+    readonly keepAlive: (sessionId: string) => Promise<RcEventWriteResult>;
+    /** Asks one session's worker for the status of its MCP server connections, returning the minted request id and the sequence numbers, or the verbose failure. */
+    readonly mcpStatus: (sessionId: string) => Promise<RcEventWriteResult>;
+    /** Asks one session's worker to reconnect one MCP server, returning the minted request id and the sequence numbers, or the verbose failure. */
+    readonly mcpReconnect: (sessionId: string, serverName: string) => Promise<RcEventWriteResult>;
+    /** Starts one MCP server's OAuth handshake on a session, returning the minted request id and the sequence numbers, or the verbose failure. */
+    readonly mcpAuthenticate: (sessionId: string, serverName: string, redirectUri: string) => Promise<RcEventWriteResult>;
+    /** Hands one MCP server's OAuth callback to a session's worker, returning the minted request id and the sequence numbers, or the verbose failure. */
+    readonly mcpOAuthCallbackUrl: (sessionId: string, serverName: string, callbackUrl: string) => Promise<RcEventWriteResult>;
+    /** Sends one teleport marker into a session over the teleport-events channel, returning the sequence numbers the service assigned, or the verbose failure. */
+    readonly teleport: (sessionId: string, marker: string) => Promise<RcEventWriteResult>;
 }
 /** Builds the control client: every request presents the control token, and a non-2xx answer becomes the verbose message the door sent with it. */
 declare function frontDoorRcControl(transport: RcControlTransport, token: string): FrontDoorRcControl;
@@ -2280,6 +2459,28 @@ interface RcApiDeps {
     readonly setModel: (sessionId: string, model: string) => Promise<RcEventWriteResult>;
     /** The set-permission-mode operation, already wired to the tracker and the door's API-host dial. */
     readonly setPermissionMode: (sessionId: string, mode: RcPermissionMode) => Promise<RcEventWriteResult>;
+    /** The end-session operation, already wired to the tracker and the door's API-host dial. */
+    readonly endSession: (sessionId: string, reason: string | undefined) => Promise<RcEventWriteResult>;
+    /** The get-usage operation, already wired to the tracker and the door's API-host dial. */
+    readonly getUsage: (sessionId: string, skipBehaviors: boolean | undefined) => Promise<RcEventWriteResult>;
+    /** The get-context-usage operation, already wired to the tracker and the door's API-host dial. */
+    readonly getContextUsage: (sessionId: string, detail: RcContextUsageDetail | undefined) => Promise<RcEventWriteResult>;
+    /** The read-file operation, already wired to the tracker and the door's API-host dial. */
+    readonly readFile: (sessionId: string, path: string, options: RcReadFileOptions | undefined) => Promise<RcEventWriteResult>;
+    /** The file-suggestions operation, already wired to the tracker and the door's API-host dial. */
+    readonly fileSuggestions: (sessionId: string, query: string) => Promise<RcEventWriteResult>;
+    /** The keep-alive operation, already wired to the tracker and the door's API-host dial. */
+    readonly keepAlive: (sessionId: string) => Promise<RcEventWriteResult>;
+    /** The mcp-status operation, already wired to the tracker and the door's API-host dial. */
+    readonly mcpStatus: (sessionId: string) => Promise<RcEventWriteResult>;
+    /** The mcp-reconnect operation, already wired to the tracker and the door's API-host dial. */
+    readonly mcpReconnect: (sessionId: string, serverName: string) => Promise<RcEventWriteResult>;
+    /** The mcp-authenticate operation, already wired to the tracker and the door's API-host dial. */
+    readonly mcpAuthenticate: (sessionId: string, serverName: string, redirectUri: string) => Promise<RcEventWriteResult>;
+    /** The mcp-oauth-callback-url operation, already wired to the tracker and the door's API-host dial. */
+    readonly mcpOAuthCallbackUrl: (sessionId: string, serverName: string, callbackUrl: string) => Promise<RcEventWriteResult>;
+    /** The teleport operation, already wired to the tracker and the door's API-host dial. */
+    readonly teleport: (sessionId: string, marker: string) => Promise<RcEventWriteResult>;
     /** The client attachment's fan-out, whose events the subscription yields. */
     readonly fanout: RcEventFanout;
 }
@@ -2355,6 +2556,7 @@ declare function createRcApiRouter(deps: RcApiDeps): {
             session: zod.ZodString;
         }, zod_v4_core.$strict>, zod.ZodObject<{
             session: zod.ZodString;
+            request: zod.ZodString;
             sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
         }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
         setModel: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
@@ -2362,6 +2564,7 @@ declare function createRcApiRouter(deps: RcApiDeps): {
             model: zod.ZodString;
         }, zod_v4_core.$strict>, zod.ZodObject<{
             session: zod.ZodString;
+            request: zod.ZodString;
             sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
         }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
         setPermissionMode: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
@@ -2374,6 +2577,101 @@ declare function createRcApiRouter(deps: RcApiDeps): {
                 dontAsk: "dontAsk";
                 auto: "auto";
             }>;
+        }, zod_v4_core.$strict>, zod.ZodObject<{
+            session: zod.ZodString;
+            request: zod.ZodString;
+            sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
+        }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
+        endSession: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
+            session: zod.ZodString;
+            reason: zod.ZodOptional<zod.ZodString>;
+        }, zod_v4_core.$strict>, zod.ZodObject<{
+            session: zod.ZodString;
+            request: zod.ZodString;
+            sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
+        }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
+        getUsage: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
+            session: zod.ZodString;
+            skipBehaviors: zod.ZodOptional<zod.ZodBoolean>;
+        }, zod_v4_core.$strict>, zod.ZodObject<{
+            session: zod.ZodString;
+            request: zod.ZodString;
+            sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
+        }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
+        getContextUsage: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
+            session: zod.ZodString;
+            detail: zod.ZodOptional<zod.ZodEnum<{
+                summary: "summary";
+                full: "full";
+            }>>;
+        }, zod_v4_core.$strict>, zod.ZodObject<{
+            session: zod.ZodString;
+            request: zod.ZodString;
+            sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
+        }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
+        readFile: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
+            session: zod.ZodString;
+            path: zod.ZodString;
+            maxBytes: zod.ZodOptional<zod.ZodNumber>;
+            encoding: zod.ZodOptional<zod.ZodEnum<{
+                "utf-8": "utf-8";
+                base64: "base64";
+            }>>;
+        }, zod_v4_core.$strict>, zod.ZodObject<{
+            session: zod.ZodString;
+            request: zod.ZodString;
+            sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
+        }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
+        fileSuggestions: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
+            session: zod.ZodString;
+            query: zod.ZodString;
+        }, zod_v4_core.$strict>, zod.ZodObject<{
+            session: zod.ZodString;
+            request: zod.ZodString;
+            sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
+        }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
+        keepAlive: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
+            session: zod.ZodString;
+        }, zod_v4_core.$strict>, zod.ZodObject<{
+            session: zod.ZodString;
+            sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
+        }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
+        mcpStatus: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
+            session: zod.ZodString;
+        }, zod_v4_core.$strict>, zod.ZodObject<{
+            session: zod.ZodString;
+            request: zod.ZodString;
+            sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
+        }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
+        mcpReconnect: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
+            session: zod.ZodString;
+            serverName: zod.ZodString;
+        }, zod_v4_core.$strict>, zod.ZodObject<{
+            session: zod.ZodString;
+            request: zod.ZodString;
+            sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
+        }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
+        mcpAuthenticate: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
+            session: zod.ZodString;
+            serverName: zod.ZodString;
+            redirectUri: zod.ZodString;
+        }, zod_v4_core.$strict>, zod.ZodObject<{
+            session: zod.ZodString;
+            request: zod.ZodString;
+            sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
+        }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
+        mcpOAuthCallbackUrl: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
+            session: zod.ZodString;
+            serverName: zod.ZodString;
+            callbackUrl: zod.ZodString;
+        }, zod_v4_core.$strict>, zod.ZodObject<{
+            session: zod.ZodString;
+            request: zod.ZodString;
+            sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
+        }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
+        teleport: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
+            session: zod.ZodString;
+            marker: zod.ZodString;
         }, zod_v4_core.$strict>, zod.ZodObject<{
             session: zod.ZodString;
             sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
@@ -4573,6 +4871,7 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
             session: zod.ZodString;
         }, zod_v4_core.$strict>, zod.ZodObject<{
             session: zod.ZodString;
+            request: zod.ZodString;
             sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
         }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
         setModel: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
@@ -4580,6 +4879,7 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
             model: zod.ZodString;
         }, zod_v4_core.$strict>, zod.ZodObject<{
             session: zod.ZodString;
+            request: zod.ZodString;
             sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
         }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
         setPermissionMode: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
@@ -4592,6 +4892,101 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
                 dontAsk: "dontAsk";
                 auto: "auto";
             }>;
+        }, zod_v4_core.$strict>, zod.ZodObject<{
+            session: zod.ZodString;
+            request: zod.ZodString;
+            sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
+        }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
+        endSession: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
+            session: zod.ZodString;
+            reason: zod.ZodOptional<zod.ZodString>;
+        }, zod_v4_core.$strict>, zod.ZodObject<{
+            session: zod.ZodString;
+            request: zod.ZodString;
+            sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
+        }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
+        getUsage: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
+            session: zod.ZodString;
+            skipBehaviors: zod.ZodOptional<zod.ZodBoolean>;
+        }, zod_v4_core.$strict>, zod.ZodObject<{
+            session: zod.ZodString;
+            request: zod.ZodString;
+            sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
+        }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
+        getContextUsage: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
+            session: zod.ZodString;
+            detail: zod.ZodOptional<zod.ZodEnum<{
+                summary: "summary";
+                full: "full";
+            }>>;
+        }, zod_v4_core.$strict>, zod.ZodObject<{
+            session: zod.ZodString;
+            request: zod.ZodString;
+            sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
+        }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
+        readFile: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
+            session: zod.ZodString;
+            path: zod.ZodString;
+            maxBytes: zod.ZodOptional<zod.ZodNumber>;
+            encoding: zod.ZodOptional<zod.ZodEnum<{
+                "utf-8": "utf-8";
+                base64: "base64";
+            }>>;
+        }, zod_v4_core.$strict>, zod.ZodObject<{
+            session: zod.ZodString;
+            request: zod.ZodString;
+            sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
+        }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
+        fileSuggestions: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
+            session: zod.ZodString;
+            query: zod.ZodString;
+        }, zod_v4_core.$strict>, zod.ZodObject<{
+            session: zod.ZodString;
+            request: zod.ZodString;
+            sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
+        }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
+        keepAlive: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
+            session: zod.ZodString;
+        }, zod_v4_core.$strict>, zod.ZodObject<{
+            session: zod.ZodString;
+            sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
+        }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
+        mcpStatus: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
+            session: zod.ZodString;
+        }, zod_v4_core.$strict>, zod.ZodObject<{
+            session: zod.ZodString;
+            request: zod.ZodString;
+            sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
+        }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
+        mcpReconnect: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
+            session: zod.ZodString;
+            serverName: zod.ZodString;
+        }, zod_v4_core.$strict>, zod.ZodObject<{
+            session: zod.ZodString;
+            request: zod.ZodString;
+            sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
+        }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
+        mcpAuthenticate: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
+            session: zod.ZodString;
+            serverName: zod.ZodString;
+            redirectUri: zod.ZodString;
+        }, zod_v4_core.$strict>, zod.ZodObject<{
+            session: zod.ZodString;
+            request: zod.ZodString;
+            sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
+        }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
+        mcpOAuthCallbackUrl: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
+            session: zod.ZodString;
+            serverName: zod.ZodString;
+            callbackUrl: zod.ZodString;
+        }, zod_v4_core.$strict>, zod.ZodObject<{
+            session: zod.ZodString;
+            request: zod.ZodString;
+            sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
+        }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
+        teleport: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
+            session: zod.ZodString;
+            marker: zod.ZodString;
         }, zod_v4_core.$strict>, zod.ZodObject<{
             session: zod.ZodString;
             sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
@@ -5845,5 +6240,5 @@ interface PrepareClaudeLaunchOptions {
  */
 declare function prepareClaudeLaunch(options: PrepareClaudeLaunchOptions): LaunchPlan;
 
-export { AMBIENT_CREDENTIAL_VARS, CHECK_CREDENTIAL_APPLIES, CONNECT_INTERCEPT_HOST, CONNECT_INTERCEPT_HOSTS, CONNECT_LIMITS, CONTROL_PATH_PREFIX, CategoryClassificationOverlaySchema, CategoryClassificationSchema, CategoryMapSchema, CheckReportJsonSchema, CheckRunInputSchema, CliError, ConfigProfileSchema, CredentialCacheSchema, CredentialSchema, CredentialSourceSchema, DOOR_EVENT_BUFFER_EVENTS, DOOR_EVENT_SOURCE_RC, DirectoryRuleAlreadyExistsError, DirectoryRuleMissingTargetError, DirectoryRuleNotFoundError, DirectoryRuleSchema, DirectoryRulesSchema, DoctorFindingSchema, DoctorRunOutputSchema, DoorEventSchema, DoorEventSourceQuerySchema, EXIT_FAILURE, EXIT_USAGE, EffectiveWindowSchema, EntryValueSchema, FARM_MANIFEST_FILENAME, FrontDoorSessionStatusSchema, FrontDoorSessionsOutputSchema, FrontDoorStartError, FrontDoorStateSchema, FrontDoorStatusOutputSchema, GlobalConfigSchema, HeadroomSocketTargetSchema, HeadroomStartError, IdentityAlreadyExistsError, IdentityNotFoundError, IdentitySchema, InvalidCategoryNameError, InvalidIdentityNameError, InvalidProviderNameError, LAUNCH_EVENT_SOURCE, LaunchLifecycleEventSchema, LaunchRefusedError, LegacyProviderFileError, PROMPT_CACHE_TTL_MS, PlanClassSchema, PoolNameSchema, PoolNotFoundError, PoolPickReportSchema, PoolSchema, PortableConfigSchema, ProfileAlreadyExistsError, ProfileNotFoundError, ProviderAlreadyExistsError, ProviderKindMismatchError, ProviderNotFoundError, ProviderSchema, RC_IDLE_EXPIRY_MS, RC_ORPC_PATH_PREFIX, RC_PENDING_DEADLINE_MS, RC_PERMISSION_MODES, RC_REQUEST_PARSE_CAP_BYTES, RC_SELF_HOST_ENV, RC_SELF_HOST_KEEPALIVE_MS, RC_SELF_HOST_RECORD_DIR, RC_SELF_HOST_RECORD_FILE, RC_SELF_HOST_RETENTION_MS, RC_SELF_HOST_SCOPE_LIST, RC_SELF_HOST_WORKER_JWT_TTL_SECONDS, RC_SESSIONS_PATH_PREFIX, RC_STREAM_BACKOFF_MS, RC_WEB_FETCH_ALLOW_PRIVATE_ENV, RC_WEB_FETCH_DEADLINE_MS, RC_WEB_FETCH_MAX_BYTES, RC_WEB_FETCH_MAX_REDIRECTS, ROUTED_PATH_PREFIX, RcPermissionModeSchema, RcStreamEnvelopeSchema, RcStreamEventSchema, UsageError, UsageListOutputSchema, UsageSnapshotError, UsageSnapshotSchema, UsageWindowsInputSchema, UsageWindowsOutputSchema, WhenSchema, addDirectoryRule, addIdentity, addPool, addProvider, answerRcControlRequest, buildEntryFacts, buildLayoutPaths, buildRcControlResponsePayload, buildRcEventWriteBody, buildRcInterruptPayload, buildRcSetModelPayload, buildRcSetPermissionModePayload, buildRcUserMessagePayload, carryOver, checkReportHasWarnings, checkReportToJson, collectCheckReport, collectDoctorReport, collectFrontDoorStatus, collectPoolPick, createControlApiRouter, createDoorApiNodeHandler, createDoorApiRouter, createDoorEventHub, createEventsApiRouter, createLaunchEventPublisher, createLeafCache, createProfile, createRcApiNodeHandler, createRcApiRouter, createRcControlHandler, createRcCredentialStore, createRcEventFanout, createRcSelfHostSurface, createRcSessionTracker, createRcStreamHub, createSseParser, describeProviderEndpoint, detectAmbientCredential, doorApiAuth, doorApiNodeHandlerOf, effectiveWindow, ensureCa, ensureFrontDoor, ensureHeadroom, evaluateAmbientCredentialGuard, evaluateWhen, fetchThroughWebProxy, formatAmbientCredentialGuardMessage, formatCheckReport, formatDoctorReport, formatFrontDoorStatus, forwardableHeaders, frontDoorApiClient, frontDoorApiLink, frontDoorRcApiClient, frontDoorRcControl, generateCa, headroomSocketTarget, identityExists, injectRcUserMessage, interruptRcSession, isIdentityDirectoryName, isInterceptedHost, isPrivateAddress, isRcPermissionMode, lateRcEventDial, lateRcStreamDial, listDirectoryRules, listIdentities, listProfiles, listProviders, listUsageSnapshots, matchBranch, mintLeaf, mintRcSelfHostCredential, observingRoutedRoute, parseConnectTarget, parseRcStreamEnvelope, planOf, prepareClaudeLaunch, prepareLaunch, profileExists, providerExists, rankPool, rcEventWriteResultFromAnswer, rcFanoutOnDoorHub, rcObserverAsPassthrough, rcSelfHostFromEnv, rcWebFetchAllowsPrivateFromEnv, readActiveIdentity, readDirectoryRules, readFarmManifest, readGlobalConfig, readIdentity, readPools, readProfile, readProvider, readRcSelfHostRecord, readUsageSnapshot, realConnectCertStore, realConnectEffects, realRcControlTransport, realRcEventDial, realRcStreamDial, realRcWebFetch, recoverFarm, recoveryDiagnostics, removeDirectoryRule, removeIdentity, removePool, removeProfile, removeProvider, requirePool, resolveAgentShimHome, resolveClaudeHome, resolveDecisions, resolveLayoutPaths, resolveSupervisorConfig, resyncFarm, runCheck, runDoctor, runFrontDoorSupervisor, runLauncher, runSupervisor, servedByPipeline, setAllowAmbientCredential, setDefaultConfigProfile, setGlobalDefaultProfile, setIdentityCredential, setPool, setProfileCategories, setProfileEntries, setProfileLaunchFlags, setProfileMetadata, setRcSessionModel, setRcSessionPermissionMode, snapshotPath, spawnClaude, startConnectServer, topLevelNames, updateDirectoryRule, updateProvider, useIdentity, writeDirectoryRules };
-export type { AddDirectoryRuleOptions, AddProviderInput, AmbientCredentialDetection, AmbientCredentialGuardResult, AmbientCredentialVar, BuildEntryFactsParams, CaMaterial, Candidate, CarryOverParams, CarryOverResult, CategoryMap, CheckReport, CheckReportJson, CollectCheckReportParams, CollectDoctorReportParams, CompiledRule, ConditionContext, ConfigProfile, ConnectCertStore, ConnectEffects, ConnectLimits, ConnectLocalSurface, ConnectServerConfig, ConnectServerHandle, ConnectTarget, ControlApiClient, ControlApiDeps, ControlApiRouter, Credential, CredentialSource, Decision, Diagnostic, DirectoryRule, DirectoryRules, DoctorReport, DoorApiClient, DoorApiContext, DoorApiDeps, DoorApiRouter, DoorEvent, DoorEventHub, DoorEventPublisher, DoorEventStream, DoorEventsApiDeps, EffectiveWindow, EliminatedRule, EnsureFrontDoorPorts, EnsureHeadroomPorts, EntryFact, EntryFacts, EntryValue, EvaluateAmbientCredentialGuardParams, FlattenedCascade, FrontDoorRcControl, FrontDoorSessionStatus, FrontDoorStatus, FrontDoorSupervisorPorts, GlobalConfig, HeadroomSupervisorConfig, Identity, IdentityCredentialChange, IdentityListEntry, IdentityListing, InjectedCredential, LaunchEventPublisher, LaunchLifecycleEvent, LaunchPlan, Layer, LayerId, LayoutPaths, LeafCert, NestedContribution, PlanClass, Pool, PoolMember, PoolPickReport, PoolRanking, PortableConfig, PrepareClaudeLaunchOptions, PrepareLaunchParams, ProfileListEntry, Provider, ProviderListEntry, RankPoolInput, RcAnswerDecision, RcAnswerDeps, RcApiClient, RcApiDeps, RcApiRouter, RcControlAnswer, RcControlHandlerDeps, RcControlRequestDeps, RcControlTransport, RcCredentialStore, RcDialAnswer, RcDialTarget, RcEventDial, RcEventFanout, RcEventWriteResult, RcExchangeObserver, RcInjectDeps, RcObservedCredential, RcObservedRequest, RcPendingRequestSummary, RcPermissionMode, RcPresenceAnswer, RcSelfHostCredentialRecord, RcSelfHostDeps, RcSelfHostMintResult, RcSelfHostSurface, RcSessionStatus, RcSessionSummary, RcSessionTracker, RcSessionTrackerDeps, RcStreamAnswer, RcStreamDial, RcStreamEnvelope, RcStreamEvent, RcStreamHub, RcStreamHubDeps, RcWebFetchDeps, RcWebFetchHop, RcWebFetchOutcome, RcWebFetcher, RcWorkerFact, RcWriteHeaders, RecoverFarmParams, RecoveryResult, ResolveDecisionsInput, ResolvedState, ResyncFarmParams, ResyncFarmResult, RunCheckParams, RunDoctorParams, RunFrontDoorSupervisorOptions, RunLauncherParams, RunSupervisorOptions, SpawnClaudeParams, SseParsedEvent, StickyPick, SupervisorPorts, UnreadableIdentityListEntry, UpdateDirectoryRuleOptions, UpdateProviderInput, UsageReadFs, UsageSnapshot, WhenCondition, WhenEvaluation };
+export { AMBIENT_CREDENTIAL_VARS, CHECK_CREDENTIAL_APPLIES, CONNECT_INTERCEPT_HOST, CONNECT_INTERCEPT_HOSTS, CONNECT_LIMITS, CONTROL_PATH_PREFIX, CategoryClassificationOverlaySchema, CategoryClassificationSchema, CategoryMapSchema, CheckReportJsonSchema, CheckRunInputSchema, CliError, ConfigProfileSchema, CredentialCacheSchema, CredentialSchema, CredentialSourceSchema, DOOR_EVENT_BUFFER_EVENTS, DOOR_EVENT_SOURCE_RC, DirectoryRuleAlreadyExistsError, DirectoryRuleMissingTargetError, DirectoryRuleNotFoundError, DirectoryRuleSchema, DirectoryRulesSchema, DoctorFindingSchema, DoctorRunOutputSchema, DoorEventSchema, DoorEventSourceQuerySchema, EXIT_FAILURE, EXIT_USAGE, EffectiveWindowSchema, EntryValueSchema, FARM_MANIFEST_FILENAME, FrontDoorSessionStatusSchema, FrontDoorSessionsOutputSchema, FrontDoorStartError, FrontDoorStateSchema, FrontDoorStatusOutputSchema, GlobalConfigSchema, HeadroomSocketTargetSchema, HeadroomStartError, IdentityAlreadyExistsError, IdentityNotFoundError, IdentitySchema, InvalidCategoryNameError, InvalidIdentityNameError, InvalidProviderNameError, LAUNCH_EVENT_SOURCE, LaunchLifecycleEventSchema, LaunchRefusedError, LegacyProviderFileError, PROMPT_CACHE_TTL_MS, PlanClassSchema, PoolNameSchema, PoolNotFoundError, PoolPickReportSchema, PoolSchema, PortableConfigSchema, ProfileAlreadyExistsError, ProfileNotFoundError, ProviderAlreadyExistsError, ProviderKindMismatchError, ProviderNotFoundError, ProviderSchema, RC_CONTEXT_USAGE_DETAILS, RC_IDLE_EXPIRY_MS, RC_ORPC_PATH_PREFIX, RC_PENDING_DEADLINE_MS, RC_PERMISSION_MODES, RC_READ_FILE_ENCODINGS, RC_REQUEST_PARSE_CAP_BYTES, RC_SELF_HOST_ENV, RC_SELF_HOST_KEEPALIVE_MS, RC_SELF_HOST_RECORD_DIR, RC_SELF_HOST_RECORD_FILE, RC_SELF_HOST_RETENTION_MS, RC_SELF_HOST_SCOPE_LIST, RC_SELF_HOST_WORKER_JWT_TTL_SECONDS, RC_SESSIONS_PATH_PREFIX, RC_STREAM_BACKOFF_MS, RC_WEB_FETCH_ALLOW_PRIVATE_ENV, RC_WEB_FETCH_DEADLINE_MS, RC_WEB_FETCH_MAX_BYTES, RC_WEB_FETCH_MAX_REDIRECTS, ROUTED_PATH_PREFIX, RcPermissionModeSchema, RcStreamEnvelopeSchema, RcStreamEventSchema, UsageError, UsageListOutputSchema, UsageSnapshotError, UsageSnapshotSchema, UsageWindowsInputSchema, UsageWindowsOutputSchema, WhenSchema, addDirectoryRule, addIdentity, addPool, addProvider, answerRcControlRequest, authenticateRcSessionMcpServer, buildEntryFacts, buildLayoutPaths, buildRcControlRequestPayload, buildRcControlResponsePayload, buildRcEndSessionPayload, buildRcEventWriteBody, buildRcFileSuggestionsPayload, buildRcGetContextUsagePayload, buildRcGetUsagePayload, buildRcInterruptPayload, buildRcKeepAlivePayload, buildRcMarkReadBody, buildRcMcpAuthenticatePayload, buildRcMcpOAuthCallbackUrlPayload, buildRcMcpReconnectPayload, buildRcMcpStatusPayload, buildRcReadFilePayload, buildRcSetModelPayload, buildRcSetPermissionModePayload, buildRcUserMessagePayload, carryOver, checkReportHasWarnings, checkReportToJson, collectCheckReport, collectDoctorReport, collectFrontDoorStatus, collectPoolPick, createControlApiRouter, createDoorApiNodeHandler, createDoorApiRouter, createDoorEventHub, createEventsApiRouter, createLaunchEventPublisher, createLeafCache, createProfile, createRcApiNodeHandler, createRcApiRouter, createRcControlHandler, createRcCredentialStore, createRcEventFanout, createRcSelfHostSurface, createRcSessionTracker, createRcStreamHub, createSseParser, describeProviderEndpoint, detectAmbientCredential, doorApiAuth, doorApiNodeHandlerOf, effectiveWindow, endRcSession, ensureCa, ensureFrontDoor, ensureHeadroom, evaluateAmbientCredentialGuard, evaluateWhen, fetchThroughWebProxy, formatAmbientCredentialGuardMessage, formatCheckReport, formatDoctorReport, formatFrontDoorStatus, forwardableHeaders, frontDoorApiClient, frontDoorApiLink, frontDoorRcApiClient, frontDoorRcControl, generateCa, getRcSessionContextUsage, getRcSessionMcpStatus, getRcSessionUsage, headroomSocketTarget, identityExists, injectRcUserMessage, interruptRcSession, isIdentityDirectoryName, isInterceptedHost, isPrivateAddress, isRcContextUsageDetail, isRcPermissionMode, isRcReadFileEncoding, lateRcEventDial, lateRcStreamDial, listDirectoryRules, listIdentities, listProfiles, listProviders, listUsageSnapshots, matchBranch, mintLeaf, mintRcSelfHostCredential, observingRoutedRoute, parseConnectTarget, parseRcStreamEnvelope, planOf, prepareClaudeLaunch, prepareLaunch, profileExists, providerExists, rankPool, rcEventWriteResultFromAnswer, rcFanoutOnDoorHub, rcObserverAsPassthrough, rcSelfHostFromEnv, rcWebFetchAllowsPrivateFromEnv, readActiveIdentity, readDirectoryRules, readFarmManifest, readGlobalConfig, readIdentity, readPools, readProfile, readProvider, readRcSelfHostRecord, readRcSessionFile, readUsageSnapshot, realConnectCertStore, realConnectEffects, realRcControlTransport, realRcEventDial, realRcStreamDial, realRcWebFetch, reconnectRcSessionMcpServer, recoverFarm, recoveryDiagnostics, removeDirectoryRule, removeIdentity, removePool, removeProfile, removeProvider, requirePool, resolveAgentShimHome, resolveClaudeHome, resolveDecisions, resolveLayoutPaths, resolveSupervisorConfig, resyncFarm, runCheck, runDoctor, runFrontDoorSupervisor, runLauncher, runSupervisor, sendRcKeepAlive, servedByPipeline, setAllowAmbientCredential, setDefaultConfigProfile, setGlobalDefaultProfile, setIdentityCredential, setPool, setProfileCategories, setProfileEntries, setProfileLaunchFlags, setProfileMetadata, setRcSessionModel, setRcSessionPermissionMode, snapshotPath, spawnClaude, startConnectServer, submitRcSessionMcpOAuthCallbackUrl, suggestRcSessionFiles, teleportRcSession, topLevelNames, updateDirectoryRule, updateProvider, useIdentity, writeDirectoryRules };
+export type { AddDirectoryRuleOptions, AddProviderInput, AmbientCredentialDetection, AmbientCredentialGuardResult, AmbientCredentialVar, BuildEntryFactsParams, CaMaterial, Candidate, CarryOverParams, CarryOverResult, CategoryMap, CheckReport, CheckReportJson, CollectCheckReportParams, CollectDoctorReportParams, CompiledRule, ConditionContext, ConfigProfile, ConnectCertStore, ConnectEffects, ConnectLimits, ConnectLocalSurface, ConnectServerConfig, ConnectServerHandle, ConnectTarget, ControlApiClient, ControlApiDeps, ControlApiRouter, Credential, CredentialSource, Decision, Diagnostic, DirectoryRule, DirectoryRules, DoctorReport, DoorApiClient, DoorApiContext, DoorApiDeps, DoorApiRouter, DoorEvent, DoorEventHub, DoorEventPublisher, DoorEventStream, DoorEventsApiDeps, EffectiveWindow, EliminatedRule, EnsureFrontDoorPorts, EnsureHeadroomPorts, EntryFact, EntryFacts, EntryValue, EvaluateAmbientCredentialGuardParams, FlattenedCascade, FrontDoorRcControl, FrontDoorSessionStatus, FrontDoorStatus, FrontDoorSupervisorPorts, GlobalConfig, HeadroomSupervisorConfig, Identity, IdentityCredentialChange, IdentityListEntry, IdentityListing, InjectedCredential, LaunchEventPublisher, LaunchLifecycleEvent, LaunchPlan, Layer, LayerId, LayoutPaths, LeafCert, NestedContribution, PlanClass, Pool, PoolMember, PoolPickReport, PoolRanking, PortableConfig, PrepareClaudeLaunchOptions, PrepareLaunchParams, ProfileListEntry, Provider, ProviderListEntry, RankPoolInput, RcAnswerDecision, RcAnswerDeps, RcApiClient, RcApiDeps, RcApiRouter, RcContextUsageDetail, RcControlAnswer, RcControlHandlerDeps, RcControlRequestDeps, RcControlTransport, RcCredentialStore, RcDialAnswer, RcDialTarget, RcEventDial, RcEventFanout, RcEventWriteResult, RcExchangeObserver, RcInjectDeps, RcObservedCredential, RcObservedRequest, RcPendingRequestSummary, RcPermissionMode, RcPresenceAnswer, RcReadFileEncoding, RcReadFileOptions, RcSelfHostCredentialRecord, RcSelfHostDeps, RcSelfHostMintResult, RcSelfHostSurface, RcSessionStatus, RcSessionSummary, RcSessionTracker, RcSessionTrackerDeps, RcStreamAnswer, RcStreamDial, RcStreamEnvelope, RcStreamEvent, RcStreamHub, RcStreamHubDeps, RcWebFetchDeps, RcWebFetchHop, RcWebFetchOutcome, RcWebFetcher, RcWorkerFact, RcWriteHeaders, RecoverFarmParams, RecoveryResult, ResolveDecisionsInput, ResolvedState, ResyncFarmParams, ResyncFarmResult, RunCheckParams, RunDoctorParams, RunFrontDoorSupervisorOptions, RunLauncherParams, RunSupervisorOptions, SpawnClaudeParams, SseParsedEvent, StickyPick, SupervisorPorts, UnreadableIdentityListEntry, UpdateDirectoryRuleOptions, UpdateProviderInput, UsageReadFs, UsageSnapshot, WhenCondition, WhenEvaluation };