agent-shim 8.25.0 → 8.27.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 {
@@ -3843,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.
  *
@@ -3857,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. */
@@ -3965,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<{
@@ -4442,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<{
@@ -5008,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<{
@@ -5117,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;
@@ -5242,6 +5488,39 @@ 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 full scope list the minting writes and the local refresh echoes: the CLI's own claude.ai login scope set (`CLAUDE_AI_OAUTH_SCOPES` in its source), whose `user:inference` and `user:profile` members are exactly the two the Remote Control gate demands. Lives here, beside the refresh that echoes it, and is re-exported by the surface so the library surface it already published is unchanged.
+ */
+declare const RC_SELF_HOST_SCOPE_LIST: readonly string[];
+/** The local surface the self-hosted service hands to the connect surface: which hosts it takes over as HTTP, and the requests it answers itself. */
+interface RcSelfHostLocal {
+    /** The hosts whose terminated sessions this surface needs parsed as HTTP (the control-plane host, normally byte-tapped). */
+    readonly parsesHost: (host: string) => boolean;
+    /** Serves one request locally; resolves false when the surface does not own the path, so routing or piping continues unchanged. */
+    readonly serve: (host: string, request: IncomingMessage, response: ServerResponse) => Promise<boolean>;
+}
+
 /**
  * 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.
  *
@@ -5307,6 +5586,8 @@ declare function realRcWebFetch(options: {
  *
  * Division of the surface: the session family (`/v1/code/sessions...` and the `/v1/sessions` compatibility list) rides the routed pipeline as a `FrontDoorRoute`, so it flows through the same admission and middleware as any routed request and, above all, through the same observation wrapper that feeds the tracker (the door's own client half learns each session's credential precisely because the create is observed like any other exchange). The non-`/v1/` answers the CLI needs around activation (feature eval, profile, telemetry no-ops) and the OAuth refresh on the control-plane host have no pipeline to ride, so they are served by `local`, which the connect surface consults before routing or piping; that surface also takes over the control-plane host's terminated session as ordinary HTTP (it is normally byte-tapped) because answering `/v1/oauth/token` requires parsing it.
  *
+ * Above the sessions sits the conversation, the native service's own keying as observed through two bridged TUIs holding two distinct `cse_` ids over one live conversation (#238's finding): the event log and its sequence space belong to the conversation, and the `cse_` sessions are attachments to it. A create that names no conversation mints a fresh one, so the single-session shape every door-observed CLI runs keeps exactly its previous behaviour under a wrapper; a create that names one attaches to it, and every write through either attachment numbers in the one shared space and fans to every stream the conversation holds, each worker's own writes excepted (feeding a worker its own writes back would loop its REPL, while the other attachment's worker writes are the other client's half of the conversation, exactly what a second TUI joins to see). No observed wire shape names the link: the create body, the bridge answer and every envelope the captures and the 2.1.289 bundle show carry no conversation id, so the linking vocabulary here (the create body's `conversation` field, the `conv_` id prefix, the session rows' `conversation_id`, and the `/v1/code/conversations` family a sessionless client reads, writes and subscribes through) is this door's own design, named as such; should the real service's shape ever surface, these are the pieces to realign.
+ *
  * The worker family includes the two web proxies the CLI dials only when its environment opts in (`CLAUDE_CODE_WEBFETCH_USE_CCR_PROXY` and `CLAUDE_CODE_WEBSEARCH_USE_CCR_PROXY`, both unset by default and both verified absent from the rig session, so the default session fetches directly and never dials them): `/{cse}/worker/web-fetch` carries the CLI's URL fetch (a POST of `{url}` answered with the fetched facts or a target refusal, both shapes the 2.1.289 client's own schema reads), and `/{cse}/worker/web-search` carries its search. The wire facts the live rig settled beside the source: the session id the proxy URL names comes from a `CLAUDE_CODE_SESSION_ID` latch that only the cloud worker shape provisions (a locally launched bridge never sets it), and the credential the client presents is the session ingress token read from `CLAUDE_SESSION_INGRESS_TOKEN_FILE` or the well-known remote directory, which locally is nothing at all, so a bare local launch sends no Authorization and is refused; when the ingress token is one of this surface's own worker JWTs it authenticates exactly as the worker family's other paths do. The paths also accept the minted credential itself, the shape the client's login-bearer fallback presents, whose principal is the same credential that created the session. The fetch's bounds live in `rcWebFetch.ts`; the search is served as a clear refusal naming that no backend ships, with the injection point a real backend answers through.
  *
  * The one network lever this uses is the bridge response's `api_base_url`: the protocol lets the server name where the worker dials, so the door names the API host it itself terminates, and the worker's `/worker/...` calls arrive straight back at this surface over the same interception that carried the create.
@@ -5317,8 +5598,6 @@ declare function realRcWebFetch(options: {
 declare const RC_SELF_HOST_ENV = "AGENT_SHIM_FRONTDOOR_RC_SELF_HOST";
 /** Whether the environment asked for the self-hosted Remote Control service. */
 declare function rcSelfHostFromEnv(env: NodeJS.ProcessEnv): boolean;
-/** The full scope list the minting writes and the local refresh echoes: the CLI's own claude.ai login scope set (`CLAUDE_AI_OAUTH_SCOPES` in its source), whose `user:inference` and `user:profile` members are exactly the two the Remote Control gate demands. */
-declare const RC_SELF_HOST_SCOPE_LIST: readonly string[];
 /**
  * How long a minted worker JWT is good for. Not a fresh number: 46800 seconds is the `expires_in` the real bridge handed the live rig session (13 hours), so the local surface keeps the CLI's refresh cadence exactly where the real one put it.
  */
@@ -5373,15 +5652,10 @@ interface RcSelfHostDeps {
 }
 /** The self-hosted Remote Control service: the session-family route for the pipeline, and the local answers the connect surface consults before routing or piping. */
 interface RcSelfHostSurface {
-    /** The pipeline route serving the whole `/v1/code/sessions` family and the `/v1/sessions` compatibility list. */
+    /** The pipeline route serving the whole `/v1/code/sessions` family, the `/v1/sessions` compatibility list and the `/v1/code/conversations` family. */
     readonly route: FrontDoorRoute;
     /** The connect surface's local answers: which hosts it takes over as HTTP, and the requests it answers itself. */
-    readonly local: {
-        /** The hosts whose terminated sessions this surface needs parsed as HTTP (the control-plane host, normally byte-tapped). */
-        readonly parsesHost: (host: string) => boolean;
-        /** Serves one request locally; resolves false when the surface does not own the path, so routing or piping continues unchanged. */
-        readonly serve: (host: string, request: IncomingMessage, response: ServerResponse) => Promise<boolean>;
-    };
+    readonly local: RcSelfHostLocal;
     /** Stops the service's timers and retires every open stream. The sessions themselves are unreachable the moment the door drops them. */
     readonly close: () => void;
 }
@@ -6240,5 +6514,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, buildRcMarkReadBody, buildRcMcpAuthenticatePayload, buildRcMcpOAuthCallbackUrlPayload, buildRcMcpReconnectPayload, buildRcMcpStatusPayload, buildRcReadFilePayload, buildRcSetModelPayload, buildRcSetPermissionModePayload, buildRcUserMessagePayload, carryOver, checkReportHasWarnings, checkReportToJson, collectCheckReport, collectDoctorReport, collectFrontDoorStatus, collectPoolPick, createControlApiRouter, createDoorApiNodeHandler, createDoorApiRouter, createDoorEventHub, createEventsApiRouter, createLaunchEventPublisher, createLeafCache, createProfile, createRcApiNodeHandler, createRcApiRouter, createRcControlHandler, createRcCredentialStore, createRcEventFanout, createRcSelfHostSurface, createRcSessionTracker, createRcStreamHub, createSseParser, describeProviderEndpoint, detectAmbientCredential, doorApiAuth, doorApiNodeHandlerOf, effectiveWindow, endRcSession, ensureCa, ensureFrontDoor, ensureHeadroom, evaluateAmbientCredentialGuard, evaluateWhen, fetchThroughWebProxy, formatAmbientCredentialGuardMessage, formatCheckReport, formatDoctorReport, formatFrontDoorStatus, forwardableHeaders, frontDoorApiClient, frontDoorApiLink, frontDoorRcApiClient, frontDoorRcControl, generateCa, getRcSessionContextUsage, getRcSessionMcpStatus, getRcSessionUsage, headroomSocketTarget, identityExists, injectRcUserMessage, interruptRcSession, isIdentityDirectoryName, isInterceptedHost, isPrivateAddress, isRcContextUsageDetail, isRcPermissionMode, isRcReadFileEncoding, lateRcEventDial, lateRcStreamDial, listDirectoryRules, listIdentities, listProfiles, listProviders, listUsageSnapshots, matchBranch, mintLeaf, mintRcSelfHostCredential, observingRoutedRoute, parseConnectTarget, parseRcStreamEnvelope, planOf, prepareClaudeLaunch, prepareLaunch, profileExists, providerExists, rankPool, rcEventWriteResultFromAnswer, rcFanoutOnDoorHub, rcObserverAsPassthrough, rcSelfHostFromEnv, rcWebFetchAllowsPrivateFromEnv, readActiveIdentity, readDirectoryRules, readFarmManifest, readGlobalConfig, readIdentity, readPools, readProfile, readProvider, readRcSelfHostRecord, readRcSessionFile, readUsageSnapshot, realConnectCertStore, realConnectEffects, realRcControlTransport, realRcEventDial, realRcStreamDial, realRcWebFetch, reconnectRcSessionMcpServer, recoverFarm, recoveryDiagnostics, removeDirectoryRule, removeIdentity, removePool, removeProfile, removeProvider, requirePool, resolveAgentShimHome, resolveClaudeHome, resolveDecisions, resolveLayoutPaths, resolveSupervisorConfig, resyncFarm, runCheck, runDoctor, runFrontDoorSupervisor, runLauncher, runSupervisor, sendRcKeepAlive, servedByPipeline, setAllowAmbientCredential, setDefaultConfigProfile, setGlobalDefaultProfile, setIdentityCredential, setPool, setProfileCategories, setProfileEntries, setProfileLaunchFlags, setProfileMetadata, setRcSessionModel, setRcSessionPermissionMode, snapshotPath, spawnClaude, startConnectServer, submitRcSessionMcpOAuthCallbackUrl, suggestRcSessionFiles, teleportRcSession, topLevelNames, updateDirectoryRule, updateProvider, useIdentity, writeDirectoryRules };
-export type { AddDirectoryRuleOptions, AddProviderInput, AmbientCredentialDetection, AmbientCredentialGuardResult, AmbientCredentialVar, BuildEntryFactsParams, CaMaterial, Candidate, CarryOverParams, CarryOverResult, CategoryMap, CheckReport, CheckReportJson, CollectCheckReportParams, CollectDoctorReportParams, CompiledRule, ConditionContext, ConfigProfile, ConnectCertStore, ConnectEffects, ConnectLimits, ConnectLocalSurface, ConnectServerConfig, ConnectServerHandle, ConnectTarget, ControlApiClient, ControlApiDeps, ControlApiRouter, Credential, CredentialSource, Decision, Diagnostic, DirectoryRule, DirectoryRules, DoctorReport, DoorApiClient, DoorApiContext, DoorApiDeps, DoorApiRouter, DoorEvent, DoorEventHub, DoorEventPublisher, DoorEventStream, DoorEventsApiDeps, EffectiveWindow, EliminatedRule, EnsureFrontDoorPorts, EnsureHeadroomPorts, EntryFact, EntryFacts, EntryValue, EvaluateAmbientCredentialGuardParams, FlattenedCascade, FrontDoorRcControl, FrontDoorSessionStatus, FrontDoorStatus, FrontDoorSupervisorPorts, GlobalConfig, HeadroomSupervisorConfig, Identity, IdentityCredentialChange, IdentityListEntry, IdentityListing, InjectedCredential, LaunchEventPublisher, LaunchLifecycleEvent, LaunchPlan, Layer, LayerId, LayoutPaths, LeafCert, NestedContribution, PlanClass, Pool, PoolMember, PoolPickReport, PoolRanking, PortableConfig, PrepareClaudeLaunchOptions, PrepareLaunchParams, ProfileListEntry, Provider, ProviderListEntry, RankPoolInput, RcAnswerDecision, RcAnswerDeps, RcApiClient, RcApiDeps, RcApiRouter, RcContextUsageDetail, RcControlAnswer, RcControlHandlerDeps, RcControlRequestDeps, RcControlTransport, RcCredentialStore, RcDialAnswer, RcDialTarget, RcEventDial, RcEventFanout, RcEventWriteResult, RcExchangeObserver, RcInjectDeps, RcObservedCredential, RcObservedRequest, RcPendingRequestSummary, RcPermissionMode, RcPresenceAnswer, RcReadFileEncoding, RcReadFileOptions, RcSelfHostCredentialRecord, RcSelfHostDeps, RcSelfHostMintResult, RcSelfHostSurface, RcSessionStatus, RcSessionSummary, RcSessionTracker, RcSessionTrackerDeps, RcStreamAnswer, RcStreamDial, RcStreamEnvelope, RcStreamEvent, RcStreamHub, RcStreamHubDeps, RcWebFetchDeps, RcWebFetchHop, RcWebFetchOutcome, RcWebFetcher, RcWorkerFact, RcWriteHeaders, RecoverFarmParams, RecoveryResult, ResolveDecisionsInput, ResolvedState, ResyncFarmParams, ResyncFarmResult, RunCheckParams, RunDoctorParams, RunFrontDoorSupervisorOptions, RunLauncherParams, RunSupervisorOptions, SpawnClaudeParams, SseParsedEvent, StickyPick, SupervisorPorts, UnreadableIdentityListEntry, UpdateDirectoryRuleOptions, UpdateProviderInput, UsageReadFs, UsageSnapshot, WhenCondition, WhenEvaluation };
+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.25.0",
+  "version": "8.27.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>",