agent-shim 8.24.0 → 8.26.0

package/dist/types/index.d.ts

@@ -1712,6 +1712,73 @@ declare const RcStreamEventSchema: z.ZodObject<{
 type RcStreamEnvelope = z.output<typeof RcStreamEnvelopeSchema>;
 /** One fan-out event, as the TypeScript every in-process consumer handles it. */
 type RcStreamEvent = z.output<typeof RcStreamEventSchema>;
+/**
+ * One subscription window inside a `rate_limit_event` payload's `unifiedWindows`: the fraction of the window used and when it resets, as the CLI read them from the `anthropic-ratelimit-unified-*` response headers. Loose because the payload family grows: the door asserts the two fields it renders and carries anything else verbatim.
+ */
+declare const RcRateLimitWindowSchema: z.ZodObject<{
+    utilization: z.ZodOptional<z.ZodNumber>;
+    resetsAt: z.ZodOptional<z.ZodNumber>;
+}, z.core.$loose>;
+/** One subscription window's usage, as the TypeScript the renderers handle it. */
+type RcRateLimitWindow = z.output<typeof RcRateLimitWindowSchema>;
+/**
+ * The `rate_limit_info` a worker's `rate_limit_event` payload carries: the SDK's own `SDKRateLimitInfo`, read through the 2.1.289 bundle's schema, which is the fuller source because it adds `unifiedWindows` (the published d.ts omits it). The top-level fields describe the currently limiting window, with `rateLimitType` naming which one it is, while `unifiedWindows` carries each subscription window beside them; every `resetsAt` is unix epoch seconds. The fields the door renders are typed here and the overage trio beside them because the watch line and the page summary state them; everything else the family carries rides through verbatim. Loose for the same reason the envelope is: the family grows, the door asserts the fields it renders, and a field it does not know still reaches consumers rather than being stripped. `status` is asserted present because it is the payload's own one required field, so a payload without it is not this family and is not filed.
+ */
+declare const RcRateLimitInfoSchema: z.ZodObject<{
+    status: z.ZodString;
+    resetsAt: z.ZodOptional<z.ZodNumber>;
+    rateLimitType: z.ZodOptional<z.ZodString>;
+    utilization: z.ZodOptional<z.ZodNumber>;
+    isUsingOverage: z.ZodOptional<z.ZodBoolean>;
+    overageStatus: z.ZodOptional<z.ZodString>;
+    overageResetsAt: z.ZodOptional<z.ZodNumber>;
+    unifiedWindows: z.ZodOptional<z.ZodObject<{
+        five_hour: z.ZodOptional<z.ZodObject<{
+            utilization: z.ZodOptional<z.ZodNumber>;
+            resetsAt: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
+        seven_day: z.ZodOptional<z.ZodObject<{
+            utilization: z.ZodOptional<z.ZodNumber>;
+            resetsAt: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
+        seven_day_overage_included: z.ZodOptional<z.ZodObject<{
+            utilization: z.ZodOptional<z.ZodNumber>;
+            resetsAt: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>>;
+}, z.core.$loose>;
+/** One rate-limit payload's facts, as the TypeScript the live usage state and the renderers handle it. */
+type RcRateLimitInfo = z.output<typeof RcRateLimitInfoSchema>;
+/** One live rate-limit observation as the live usage surface reports it: the session whose stream filed it, when the door observed it (the door's own clock, epoch milliseconds), and the payload's `rate_limit_info`. */
+declare const RcLiveRateLimitSchema: z.ZodObject<{
+    session: z.ZodString;
+    observedAt: z.ZodNumber;
+    rateLimit: z.ZodObject<{
+        status: z.ZodString;
+        resetsAt: z.ZodOptional<z.ZodNumber>;
+        rateLimitType: z.ZodOptional<z.ZodString>;
+        utilization: z.ZodOptional<z.ZodNumber>;
+        isUsingOverage: z.ZodOptional<z.ZodBoolean>;
+        overageStatus: z.ZodOptional<z.ZodString>;
+        overageResetsAt: z.ZodOptional<z.ZodNumber>;
+        unifiedWindows: z.ZodOptional<z.ZodObject<{
+            five_hour: z.ZodOptional<z.ZodObject<{
+                utilization: z.ZodOptional<z.ZodNumber>;
+                resetsAt: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$loose>>;
+            seven_day: z.ZodOptional<z.ZodObject<{
+                utilization: z.ZodOptional<z.ZodNumber>;
+                resetsAt: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$loose>>;
+            seven_day_overage_included: z.ZodOptional<z.ZodObject<{
+                utilization: z.ZodOptional<z.ZodNumber>;
+                resetsAt: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>>;
+    }, z.core.$loose>;
+}, z.core.$strict>;
+/** One live rate-limit observation, as the TypeScript every in-process consumer handles it. */
+type RcLiveRateLimit = z.output<typeof RcLiveRateLimitSchema>;
 
 /** What the identity step learned about one request from the launcher-injected headers. */
 interface SessionIdentity {
@@ -1899,6 +1966,8 @@ declare function rcObserverAsPassthrough(observer: RcExchangeObserver): Passthro
  * 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.
@@ -1920,6 +1989,10 @@ 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. 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.
@@ -2128,6 +2201,14 @@ declare function submitRcSessionMcpOAuthCallbackUrl(deps: RcControlRequestDeps,
  * 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.
@@ -2163,10 +2244,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>;
@@ -2305,6 +2389,8 @@ interface RcControlHandlerDeps {
     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.
@@ -2364,6 +2450,8 @@ interface FrontDoorRcControl {
     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;
@@ -2458,6 +2546,8 @@ interface RcApiDeps {
     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;
 }
@@ -2646,6 +2736,13 @@ declare function createRcApiRouter(deps: RcApiDeps): {
             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>>;
+        }, 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<{
             session: zod.ZodOptional<zod.ZodString>;
         }, zod_v4_core.$strict>, any, Record<never, never>, Record<never, never>>;
@@ -3813,7 +3910,7 @@ declare function formatFrontDoorStatus(status: FrontDoorStatus, caCertPath: stri
 /**
  * The door's general control plane as a typed oRPC API: the read-only surfaces a programmatic consumer (automation, a dashboard, another of this user's tools) needs beyond Remote Control, one router per domain, every procedure behind the same per-generation control token as `rc.*` and validating through the Zod schemas of `controlSchemas.ts`.
  *
- * - `usage.*` reads the per-identity usage snapshots the door's own middleware writes, and reads a provider's quota windows the way every in-process consumer does (`effectiveWindow`: a window past its reset is empty and carries no status).
+ * - `usage.*` reads the per-identity usage snapshots the door's own middleware writes, reads a provider's quota windows the way every in-process consumer does (`effectiveWindow`: a window past its reset is empty and carries no status), and reads the live rate-limit observations the event backbone files off the Remote Control client stream (`live`: per-session latest state, exactly as fresh as the last turn a session completed, never a timer's derivation of it).
  * - `frontdoor.*` returns what `agent-shim frontdoor status` returns: the supervisor state, its liveness, the session registry's launches and the headroom hop.
  * - `check.run` and `doctor.run` return the reports `agent-shim check` and `agent-shim doctor` print, as data, `check.run` parameterised by an absolute directory path.
  *
@@ -3827,6 +3924,12 @@ interface ControlApiDeps {
     readonly usageSnapshots: () => readonly UsageSnapshot[];
     /** One identity's usage snapshot, as `readUsageSnapshot` reads it: undefined when the identity has none yet. */
     readonly usageSnapshotOf: (identity: string) => UsageSnapshot | undefined;
+    /** The observed Remote Control sessions as the tracker lists them, so the live quota read can tell a session that never crossed this door from one that has completed no turn through it yet. */
+    readonly list: () => readonly RcSessionSummary[];
+    /** The live rate-limit observations the door's event backbone has filed, as the live usage state reads them, filtered to one session when named. */
+    readonly liveRateLimits: (sessionId?: string) => readonly RcLiveRateLimit[];
+    /** The freshest live rate-limit observation across every session, as the live usage state reads it: undefined while no rate_limit_event has been filed at all. */
+    readonly latestRateLimit: () => RcLiveRateLimit | undefined;
     /** The clock the window semantics read a recorded window at. */
     readonly now: () => number;
     /** The door's read-only status, as `collectFrontDoorStatus` collects it. */
@@ -3935,6 +4038,64 @@ declare function createControlApiRouter(deps: ControlApiDeps): {
                 status: zod.ZodOptional<zod.ZodString>;
             }, zod_v4_core.$strict>>;
         }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
+        live: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
+            session: zod.ZodOptional<zod.ZodString>;
+        }, zod_v4_core.$strict>, zod.ZodObject<{
+            latest: zod.ZodOptional<zod.ZodObject<{
+                session: zod.ZodString;
+                observedAt: zod.ZodNumber;
+                rateLimit: zod.ZodObject<{
+                    status: zod.ZodString;
+                    resetsAt: zod.ZodOptional<zod.ZodNumber>;
+                    rateLimitType: zod.ZodOptional<zod.ZodString>;
+                    utilization: zod.ZodOptional<zod.ZodNumber>;
+                    isUsingOverage: zod.ZodOptional<zod.ZodBoolean>;
+                    overageStatus: zod.ZodOptional<zod.ZodString>;
+                    overageResetsAt: zod.ZodOptional<zod.ZodNumber>;
+                    unifiedWindows: zod.ZodOptional<zod.ZodObject<{
+                        five_hour: zod.ZodOptional<zod.ZodObject<{
+                            utilization: zod.ZodOptional<zod.ZodNumber>;
+                            resetsAt: zod.ZodOptional<zod.ZodNumber>;
+                        }, zod_v4_core.$loose>>;
+                        seven_day: zod.ZodOptional<zod.ZodObject<{
+                            utilization: zod.ZodOptional<zod.ZodNumber>;
+                            resetsAt: zod.ZodOptional<zod.ZodNumber>;
+                        }, zod_v4_core.$loose>>;
+                        seven_day_overage_included: zod.ZodOptional<zod.ZodObject<{
+                            utilization: zod.ZodOptional<zod.ZodNumber>;
+                            resetsAt: zod.ZodOptional<zod.ZodNumber>;
+                        }, zod_v4_core.$loose>>;
+                    }, zod_v4_core.$loose>>;
+                }, zod_v4_core.$loose>;
+            }, zod_v4_core.$strict>>;
+            sessions: zod.ZodReadonly<zod.ZodArray<zod.ZodObject<{
+                session: zod.ZodString;
+                observedAt: zod.ZodNumber;
+                rateLimit: zod.ZodObject<{
+                    status: zod.ZodString;
+                    resetsAt: zod.ZodOptional<zod.ZodNumber>;
+                    rateLimitType: zod.ZodOptional<zod.ZodString>;
+                    utilization: zod.ZodOptional<zod.ZodNumber>;
+                    isUsingOverage: zod.ZodOptional<zod.ZodBoolean>;
+                    overageStatus: zod.ZodOptional<zod.ZodString>;
+                    overageResetsAt: zod.ZodOptional<zod.ZodNumber>;
+                    unifiedWindows: zod.ZodOptional<zod.ZodObject<{
+                        five_hour: zod.ZodOptional<zod.ZodObject<{
+                            utilization: zod.ZodOptional<zod.ZodNumber>;
+                            resetsAt: zod.ZodOptional<zod.ZodNumber>;
+                        }, zod_v4_core.$loose>>;
+                        seven_day: zod.ZodOptional<zod.ZodObject<{
+                            utilization: zod.ZodOptional<zod.ZodNumber>;
+                            resetsAt: zod.ZodOptional<zod.ZodNumber>;
+                        }, zod_v4_core.$loose>>;
+                        seven_day_overage_included: zod.ZodOptional<zod.ZodObject<{
+                            utilization: zod.ZodOptional<zod.ZodNumber>;
+                            resetsAt: zod.ZodOptional<zod.ZodNumber>;
+                        }, zod_v4_core.$loose>>;
+                    }, zod_v4_core.$loose>>;
+                }, zod_v4_core.$loose>;
+            }, zod_v4_core.$strict>>>;
+        }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
     };
     frontdoor: {
         status: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, Schema<unknown, unknown>, zod.ZodObject<{
@@ -4412,6 +4573,64 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
                 status: zod.ZodOptional<zod.ZodString>;
             }, zod_v4_core.$strict>>;
         }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
+        live: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
+            session: zod.ZodOptional<zod.ZodString>;
+        }, zod_v4_core.$strict>, zod.ZodObject<{
+            latest: zod.ZodOptional<zod.ZodObject<{
+                session: zod.ZodString;
+                observedAt: zod.ZodNumber;
+                rateLimit: zod.ZodObject<{
+                    status: zod.ZodString;
+                    resetsAt: zod.ZodOptional<zod.ZodNumber>;
+                    rateLimitType: zod.ZodOptional<zod.ZodString>;
+                    utilization: zod.ZodOptional<zod.ZodNumber>;
+                    isUsingOverage: zod.ZodOptional<zod.ZodBoolean>;
+                    overageStatus: zod.ZodOptional<zod.ZodString>;
+                    overageResetsAt: zod.ZodOptional<zod.ZodNumber>;
+                    unifiedWindows: zod.ZodOptional<zod.ZodObject<{
+                        five_hour: zod.ZodOptional<zod.ZodObject<{
+                            utilization: zod.ZodOptional<zod.ZodNumber>;
+                            resetsAt: zod.ZodOptional<zod.ZodNumber>;
+                        }, zod_v4_core.$loose>>;
+                        seven_day: zod.ZodOptional<zod.ZodObject<{
+                            utilization: zod.ZodOptional<zod.ZodNumber>;
+                            resetsAt: zod.ZodOptional<zod.ZodNumber>;
+                        }, zod_v4_core.$loose>>;
+                        seven_day_overage_included: zod.ZodOptional<zod.ZodObject<{
+                            utilization: zod.ZodOptional<zod.ZodNumber>;
+                            resetsAt: zod.ZodOptional<zod.ZodNumber>;
+                        }, zod_v4_core.$loose>>;
+                    }, zod_v4_core.$loose>>;
+                }, zod_v4_core.$loose>;
+            }, zod_v4_core.$strict>>;
+            sessions: zod.ZodReadonly<zod.ZodArray<zod.ZodObject<{
+                session: zod.ZodString;
+                observedAt: zod.ZodNumber;
+                rateLimit: zod.ZodObject<{
+                    status: zod.ZodString;
+                    resetsAt: zod.ZodOptional<zod.ZodNumber>;
+                    rateLimitType: zod.ZodOptional<zod.ZodString>;
+                    utilization: zod.ZodOptional<zod.ZodNumber>;
+                    isUsingOverage: zod.ZodOptional<zod.ZodBoolean>;
+                    overageStatus: zod.ZodOptional<zod.ZodString>;
+                    overageResetsAt: zod.ZodOptional<zod.ZodNumber>;
+                    unifiedWindows: zod.ZodOptional<zod.ZodObject<{
+                        five_hour: zod.ZodOptional<zod.ZodObject<{
+                            utilization: zod.ZodOptional<zod.ZodNumber>;
+                            resetsAt: zod.ZodOptional<zod.ZodNumber>;
+                        }, zod_v4_core.$loose>>;
+                        seven_day: zod.ZodOptional<zod.ZodObject<{
+                            utilization: zod.ZodOptional<zod.ZodNumber>;
+                            resetsAt: zod.ZodOptional<zod.ZodNumber>;
+                        }, zod_v4_core.$loose>>;
+                        seven_day_overage_included: zod.ZodOptional<zod.ZodObject<{
+                            utilization: zod.ZodOptional<zod.ZodNumber>;
+                            resetsAt: zod.ZodOptional<zod.ZodNumber>;
+                        }, zod_v4_core.$loose>>;
+                    }, zod_v4_core.$loose>>;
+                }, zod_v4_core.$loose>;
+            }, zod_v4_core.$strict>>>;
+        }, zod_v4_core.$strict>, Record<never, never>, Record<never, never>>;
     };
     frontdoor: {
         status: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, Schema<unknown, unknown>, zod.ZodObject<{
@@ -4954,6 +5173,13 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
             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>>;
+        }, 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<{
             session: zod.ZodOptional<zod.ZodString>;
         }, zod_v4_core.$strict>, any, Record<never, never>, Record<never, never>>;
@@ -4971,7 +5197,7 @@ type DoorApiClient = RouterClient<DoorApiRouter>;
 declare function frontDoorApiClient(port: number, ca: string, token: string): DoorApiClient;
 
 /**
- * The Zod schemas of the door's general control plane: the usage snapshots a remote consumer reads, the front door's own status and session registry, the check report over a path, and the doctor report, each one the input or output of a procedure in `controlApi.ts`. Like `rcSchemas.ts` this module is a plain Zod leaf (nothing here imports oRPC), and every shape it asserts is one the implementation already defines: the usage snapshot and front-door state schemas are the store's and the registry's own, the check report's is `checkReportSchema.ts`'s (`CheckReportJsonSchema`, imported straight by the procedure), and the doctor vocabulary is `doctorReport.ts`'s own, so contract and behaviour share one source and a drift fails the procedures' own validation rather than shipping silently.
+ * The Zod schemas of the door's general control plane: the usage snapshots a remote consumer reads, the live rate-limit observations the event backbone files, the front door's own status and session registry, the check report over a path, and the doctor report, each one the input or output of a procedure in `controlApi.ts`. Like `rcSchemas.ts` this module is a plain Zod leaf (nothing here imports oRPC), and every shape it asserts is one the implementation already defines: the usage snapshot and front-door state schemas are the store's and the registry's own, the check report's is `checkReportSchema.ts`'s (`CheckReportJsonSchema`, imported straight by the procedure), and the doctor vocabulary is `doctorReport.ts`'s own, so contract and behaviour share one source and a drift fails the procedures' own validation rather than shipping silently.
  */
 /** Every usage snapshot on this machine, one per identity that has routed a request through the door. */
 declare const UsageListOutputSchema: z.ZodObject<{
@@ -5080,6 +5306,63 @@ declare const UsageWindowsOutputSchema: z.ZodObject<{
         status: z.ZodOptional<z.ZodString>;
     }, z.core.$strict>>;
 }, z.core.$strict>;
+/** The live quota read's answer: every per-session rate-limit observation the door's event backbone has filed, oldest-observed first, and the freshest one across every session. */
+declare const UsageLiveOutputSchema: z.ZodObject<{
+    latest: z.ZodOptional<z.ZodObject<{
+        session: z.ZodString;
+        observedAt: z.ZodNumber;
+        rateLimit: z.ZodObject<{
+            status: z.ZodString;
+            resetsAt: z.ZodOptional<z.ZodNumber>;
+            rateLimitType: z.ZodOptional<z.ZodString>;
+            utilization: z.ZodOptional<z.ZodNumber>;
+            isUsingOverage: z.ZodOptional<z.ZodBoolean>;
+            overageStatus: z.ZodOptional<z.ZodString>;
+            overageResetsAt: z.ZodOptional<z.ZodNumber>;
+            unifiedWindows: z.ZodOptional<z.ZodObject<{
+                five_hour: z.ZodOptional<z.ZodObject<{
+                    utilization: z.ZodOptional<z.ZodNumber>;
+                    resetsAt: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$loose>>;
+                seven_day: z.ZodOptional<z.ZodObject<{
+                    utilization: z.ZodOptional<z.ZodNumber>;
+                    resetsAt: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$loose>>;
+                seven_day_overage_included: z.ZodOptional<z.ZodObject<{
+                    utilization: z.ZodOptional<z.ZodNumber>;
+                    resetsAt: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$loose>>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>;
+    }, z.core.$strict>>;
+    sessions: z.ZodReadonly<z.ZodArray<z.ZodObject<{
+        session: z.ZodString;
+        observedAt: z.ZodNumber;
+        rateLimit: z.ZodObject<{
+            status: z.ZodString;
+            resetsAt: z.ZodOptional<z.ZodNumber>;
+            rateLimitType: z.ZodOptional<z.ZodString>;
+            utilization: z.ZodOptional<z.ZodNumber>;
+            isUsingOverage: z.ZodOptional<z.ZodBoolean>;
+            overageStatus: z.ZodOptional<z.ZodString>;
+            overageResetsAt: z.ZodOptional<z.ZodNumber>;
+            unifiedWindows: z.ZodOptional<z.ZodObject<{
+                five_hour: z.ZodOptional<z.ZodObject<{
+                    utilization: z.ZodOptional<z.ZodNumber>;
+                    resetsAt: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$loose>>;
+                seven_day: z.ZodOptional<z.ZodObject<{
+                    utilization: z.ZodOptional<z.ZodNumber>;
+                    resetsAt: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$loose>>;
+                seven_day_overage_included: z.ZodOptional<z.ZodObject<{
+                    utilization: z.ZodOptional<z.ZodNumber>;
+                    resetsAt: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$loose>>;
+            }, z.core.$loose>>;
+        }, z.core.$loose>;
+    }, z.core.$strict>>>;
+}, z.core.$strict>;
 /** One registered launch as the status surfaces list it: the launcher's pid and start time plus whether it is still running, never the session's capability token. */
 declare const FrontDoorSessionStatusSchema: z.ZodObject<{
     pid: z.ZodInt;
@@ -5205,6 +5488,27 @@ interface LaunchEventPublisher {
 /** Creates the launch lifecycle publisher. One per door process, fed by the supervisor's tick. */
 declare function createLaunchEventPublisher(hub: DoorEventHub, now: () => number): LaunchEventPublisher;
 
+/**
+ * The rate-limit facts one client read stream event carries, or undefined when the event is not a `rate_limit_event` this module can read: a payload of another type, a payload without the family's own one required field, or one whose `rate_limit_info` does not parse. An envelope the door cannot read is one it knows nothing about, never a failure, exactly as the stream's own parser treats an envelope it cannot read. Exported because the renderers (`frontdoor rc watch`, the web client's twin) narrow the same payload through the same one definition.
+ */
+declare function rcRateLimitInfoOf(event: RcStreamEvent): RcRateLimitInfo | undefined;
+/** Everything the live quota state needs, injected so its filing runs against fakes in unit tests. */
+interface RcLiveUsageDeps {
+    /** The door's clock, read at the moment an envelope is filed: the observation's `observedAt`. */
+    readonly now: () => number;
+    /** The door's event backbone, whose Remote Control source the state subscribes to. */
+    readonly hub: DoorEventHub;
+}
+/** The door's live quota state, one per door process. */
+interface RcLiveUsage {
+    /** Every observation the door holds, oldest-observed first, filtered to one session when named: the state the control plane's `usage.live` read serves. */
+    readonly liveOf: (sessionId?: string) => readonly RcLiveRateLimit[];
+    /** The freshest observation across every session, whatever filter a read names, because it is the door's single latest statement of the account's quota. */
+    readonly latestOf: () => RcLiveRateLimit | undefined;
+}
+/** Creates the live quota state and subscribes it to the backbone, so every rate-limit envelope published from now on is filed the moment it arrives. One per door process; everything it holds dies with it. */
+declare function createRcLiveUsage(deps: RcLiveUsageDeps): RcLiveUsage;
+
 /**
  * The worker's web-fetch proxy target side: the URL fetch the CLI delegates to the Remote Control host when its environment sends `CLAUDE_CODE_WEBFETCH_USE_CCR_PROXY`, served by the self-hosted surface so such a session does not break on the first fetch. The wire contract is the one the 2.1.289 CLI's own client half defines (its `THr`/`jPt` functions): a POST of `{url}` to `/{cse}/worker/web-fetch` answered with `{url, destination_url, text, content_type}` or `{error: {error_type, error_message}}`, read under a 12 MiB answer cap and a 40 s per-attempt timeout.
  *
@@ -6203,5 +6507,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_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 };
+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, RcLiveRateLimitSchema, RcPermissionModeSchema, RcRateLimitInfoSchema, RcRateLimitWindowSchema, RcStreamEnvelopeSchema, RcStreamEventSchema, UsageError, UsageListOutputSchema, UsageLiveOutputSchema, 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, createRcLiveUsage, 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, rcRateLimitInfoOf, 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, RcLiveRateLimit, RcLiveUsage, RcLiveUsageDeps, RcObservedCredential, RcObservedRequest, RcPendingRequestSummary, RcPermissionMode, RcPresenceAnswer, RcRateLimitInfo, RcRateLimitWindow, 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 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-shim",
-  "version": "8.24.0",
+  "version": "8.26.0",
   "description": "A profile manager and launcher for Claude Code that lets one person run multiple logins from one machine while controlling what gets shared between them.",
   "license": "MIT",
   "author": "Joseph Mearman <joseph@mearman.co.uk>",