agent-shim 8.22.0 → 8.24.0

package/dist/types/index.d.ts

@@ -542,6 +542,11 @@ declare const HeadroomGlobalConfigSchema: z.ZodObject<{
     readMaturation: z.ZodOptional<z.ZodBoolean>;
 }, z.core.$strict>;
 type HeadroomGlobalConfig = z.infer<typeof HeadroomGlobalConfigSchema>;
+/**
+ * The launch-time update modes. `off` never touches the network at launch; `notify` checks for a newer release on a cooldown and prints one line naming it and the command to apply it; `auto` additionally applies the update in the background.
+ */
+declare const UPDATE_MODES: readonly ["off", "notify", "auto"];
+type UpdateMode = (typeof UPDATE_MODES)[number];
 /** The user-global `~/.agent-shim/config.json`. */
 declare const GlobalConfigSchema: z.ZodObject<{
     $schema: z.ZodOptional<z.ZodString>;
@@ -602,6 +607,13 @@ declare const GlobalConfigSchema: z.ZodObject<{
     frontdoor: z.ZodOptional<z.ZodObject<{
         idleShutdownMinutes: z.ZodOptional<z.ZodNumber>;
     }, z.core.$strict>>;
+    update: z.ZodOptional<z.ZodObject<{
+        mode: z.ZodOptional<z.ZodEnum<{
+            auto: "auto";
+            off: "off";
+            notify: "notify";
+        }>>;
+    }, z.core.$strict>>;
     pools: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         identities: z.ZodArray<z.ZodString>;
         preference: z.ZodOptional<z.ZodEnum<{
@@ -1763,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.
  *
@@ -1880,6 +1892,14 @@ 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.
+ */
 /**
  * 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.
  */
@@ -1901,10 +1921,13 @@ interface RcDialAnswer {
 interface RcEventDial {
     readonly writeEvents: (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;
@@ -1947,7 +1970,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>;
 /**
@@ -1958,6 +1985,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. */
@@ -1987,17 +2077,57 @@ 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>;
 
 /**
  * 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.
@@ -2129,7 +2259,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.
  */
@@ -2155,6 +2285,26 @@ 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>;
 }
 /**
  * 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.
@@ -2176,7 +2326,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[]>;
@@ -2188,12 +2338,32 @@ 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>;
 }
 /** 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;
@@ -2268,6 +2438,26 @@ 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 client attachment's fan-out, whose events the subscription yields. */
     readonly fanout: RcEventFanout;
 }
@@ -2343,6 +2533,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<{
@@ -2350,6 +2541,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<{
@@ -2364,6 +2556,94 @@ declare function createRcApiRouter(deps: RcApiDeps): {
             }>;
         }, 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>>;
         subscribe: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
@@ -3998,13 +4278,13 @@ declare function createControlApiRouter(deps: ControlApiDeps): {
                     "config-profile": "config-profile";
                     identity: "identity";
                     provider: "provider";
+                    pool: "pool";
+                    keychain: "keychain";
                     "ambient-credential": "ambient-credential";
                     "binary-discovery": "binary-discovery";
                     "claude-shim": "claude-shim";
                     "path-resolution": "path-resolution";
                     "legacy-name": "legacy-name";
-                    pool: "pool";
-                    keychain: "keychain";
                     "directory-rules": "directory-rules";
                     "categories-local": "categories-local";
                     "active-identity": "active-identity";
@@ -4475,13 +4755,13 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
                     "config-profile": "config-profile";
                     identity: "identity";
                     provider: "provider";
+                    pool: "pool";
+                    keychain: "keychain";
                     "ambient-credential": "ambient-credential";
                     "binary-discovery": "binary-discovery";
                     "claude-shim": "claude-shim";
                     "path-resolution": "path-resolution";
                     "legacy-name": "legacy-name";
-                    pool: "pool";
-                    keychain: "keychain";
                     "directory-rules": "directory-rules";
                     "categories-local": "categories-local";
                     "active-identity": "active-identity";
@@ -4561,6 +4841,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<{
@@ -4568,6 +4849,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<{
@@ -4582,6 +4864,94 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
             }>;
         }, 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>>;
         subscribe: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
@@ -4769,13 +5139,13 @@ declare const DoctorFindingSchema: z.ZodObject<{
         "config-profile": "config-profile";
         identity: "identity";
         provider: "provider";
+        pool: "pool";
+        keychain: "keychain";
         "ambient-credential": "ambient-credential";
         "binary-discovery": "binary-discovery";
         "claude-shim": "claude-shim";
         "path-resolution": "path-resolution";
         "legacy-name": "legacy-name";
-        pool: "pool";
-        keychain: "keychain";
         "directory-rules": "directory-rules";
         "categories-local": "categories-local";
         "active-identity": "active-identity";
@@ -4798,13 +5168,13 @@ declare const DoctorRunOutputSchema: z.ZodObject<{
             "config-profile": "config-profile";
             identity: "identity";
             provider: "provider";
+            pool: "pool";
+            keychain: "keychain";
             "ambient-credential": "ambient-credential";
             "binary-discovery": "binary-discovery";
             "claude-shim": "claude-shim";
             "path-resolution": "path-resolution";
             "legacy-name": "legacy-name";
-            pool: "pool";
-            keychain: "keychain";
             "directory-rules": "directory-rules";
             "categories-local": "categories-local";
             "active-identity": "active-identity";
@@ -5672,6 +6042,24 @@ interface CliOverride {
     };
 }
 
+/**
+ * Everything the launch-time update check needs from its host, injected so tests run it against scripted answers and no launch ever reaches GitHub by accident. Deliberately narrower than `UpdatePorts`: the launch path never downloads anything (the detached `agent-shim update` does), so only the release check, the cooldown stamp, the clock, the background spawn and the terminal are wired.
+ */
+interface UpdateLaunchPort {
+    /** Resolves the URL the `releases/latest` redirect lands on, exactly as `agent-shim update` resolves the newest version. */
+    readonly effectiveUrl: (url: string) => Promise<string>;
+    /** Reads the cooldown stamp, or undefined when it does not exist. */
+    readonly readStamp: (filePath: string) => string | undefined;
+    /** Writes the cooldown stamp atomically: a reader either sees the previous whole stamp or the new one, never a partial write. */
+    readonly writeStamp: (filePath: string, contents: string) => void;
+    /** The clock the cooldown reads, in epoch milliseconds. */
+    readonly now: () => number;
+    /** Re-invokes this very binary with `args` as a detached child whose stdio is ignored and which is unref'd, so it outlives the launch and never holds the terminal. */
+    readonly spawnDetached: (args: readonly string[]) => void;
+    /** Writes one line to the launching terminal's stderr. */
+    readonly writeErr: (line: string) => void;
+}
+
 /**
  * Everything the farm resync needs that the launcher itself has no way to produce: a real filesystem, a real clock, the working directory, and a way to load the cascade for it.
  *
@@ -5732,6 +6120,10 @@ interface PrepareLaunchParams {
     readonly credentials?: CredentialPort;
     /** True when the user was asked on a terminal whether to create the selected configuration profile and chose to launch without it. Without that explicit choice, a selected profile with no file is refused rather than silently skipped. */
     readonly allowMissingConfigProfile?: boolean;
+    /** The user-global `update.mode`, resolved from the same global config the launcher already loads. Absent means `off`, and `off` runs no launch-time update check at all. */
+    readonly updateMode?: UpdateMode;
+    /** Wires the launch-time update check behind `update.mode`. Omitted by a caller that cannot resolve releases, re-invoke this binary, or write to the terminal; a mode of `notify` or `auto` with no port wired simply checks nothing. */
+    readonly update?: UpdateLaunchPort;
 }
 /** Inputs to `runLauncher`: a launch's inputs plus the port that spawns the child. */
 interface RunLauncherParams extends PrepareLaunchParams {
@@ -5746,11 +6138,13 @@ interface LaunchPlan {
     readonly env: Readonly<Record<string, string | undefined>>;
     /** Releases the daemon session registrations this launch holds. Call it when the child has exited; it is safe to call more than once. */
     readonly release: () => void;
+    /** Marks the moment this plan's child is spawned: the launch-time update check suppresses its notify line from then on, since a line printed after the child took over the terminal would land mid-session. Call it immediately before spawning; it is safe to call more than once. */
+    readonly markChildStarted: () => void;
 }
 /**
  * Prepares one `claude` launch, in order:
  *
- * `CLAUDE_CONFIG_DIR` escape-hatch check, then the identity/config-profile decision, the provider decision, the identity's own credential, the ambient-credential guard, farm resync, version discovery, flag resolution (and, when headroom resolved on, daemon bring-up), the extra-flags split, and the final argument list and environment, returned as a `LaunchPlan` for the caller to spawn. It refuses through `params.proc.exit`, so a caller that is not a command line process passes a `proc` whose `exit` throws.
+ * `CLAUDE_CONFIG_DIR` escape-hatch check, then the identity/config-profile decision, the provider decision, the identity's own credential, the ambient-credential guard, the config-gated launch-time update check (fired after the decision line and never awaited; see `runLaunchUpdateCheck`), farm resync, version discovery, flag resolution (and, when headroom resolved on, daemon bring-up), the extra-flags split, and the final argument list and environment, returned as a `LaunchPlan` for the caller to spawn. It refuses through `params.proc.exit`, so a caller that is not a command line process passes a `proc` whose `exit` throws.
  *
  * A launch that resolves an identity with no `identity.json`, or a configuration profile with no file, is refused with exit 1 naming the missing name and how it was selected: silently proceeding would create a brand-new login for a mistyped `@name`, or launch with a whole cascade layer missing. On a terminal, `src/runClaude.ts` offers to create either before this runs.
  *
@@ -5809,5 +6203,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, 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, 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 };