agent-shim 8.15.0 → 8.17.0

package/dist/types/index.d.ts

@@ -201,6 +201,10 @@ declare const CodexProviderConfigSchema: z.ZodObject<{
         medium: "medium";
         high: "high";
     }>>;
+    login: z.ZodOptional<z.ZodEnum<{
+        "codex-cli": "codex-cli";
+        "chatgpt-sign-in": "chatgpt-sign-in";
+    }>>;
 }, z.core.$strict>;
 type CodexProviderConfig = z.infer<typeof CodexProviderConfigSchema>;
 /** Either kind of provider; see `HttpProviderSchema` for the shared fields. */
@@ -299,6 +303,10 @@ declare const ProviderSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
             medium: "medium";
             high: "high";
         }>>;
+        login: z.ZodOptional<z.ZodEnum<{
+            "codex-cli": "codex-cli";
+            "chatgpt-sign-in": "chatgpt-sign-in";
+        }>>;
     }, z.core.$strict>>;
 }, z.core.$strict>], "kind">;
 type Provider = z.infer<typeof ProviderSchema>;
@@ -363,6 +371,14 @@ declare const DirectoryRuleSchema: z.ZodObject<{
             env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         }, z.core.$strict>;
     }, z.core.$strict>]>>>;
+    launch: z.ZodOptional<z.ZodObject<{
+        skipPermissions: z.ZodOptional<z.ZodBoolean>;
+        remoteControl: z.ZodOptional<z.ZodBoolean>;
+        provider: z.ZodOptional<z.ZodString>;
+        headroom: z.ZodOptional<z.ZodBoolean>;
+        trackUsage: z.ZodOptional<z.ZodBoolean>;
+        claudeVersion: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
     $schema: z.ZodOptional<z.ZodString>;
     extends: z.ZodOptional<z.ZodArray<z.ZodString>>;
     categories: z.ZodOptional<z.ZodPipe<z.ZodObject<{
@@ -378,14 +394,6 @@ declare const DirectoryRuleSchema: z.ZodObject<{
         knowledge?: boolean | undefined;
         settings?: boolean | undefined;
     }>>>;
-    launch: z.ZodOptional<z.ZodObject<{
-        skipPermissions: z.ZodOptional<z.ZodBoolean>;
-        remoteControl: z.ZodOptional<z.ZodBoolean>;
-        provider: z.ZodOptional<z.ZodString>;
-        headroom: z.ZodOptional<z.ZodBoolean>;
-        trackUsage: z.ZodOptional<z.ZodBoolean>;
-        claudeVersion: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>;
     path: z.ZodString;
     configProfile: z.ZodOptional<z.ZodString>;
     identity: z.ZodOptional<z.ZodString>;
@@ -412,6 +420,14 @@ declare const DirectoryRulesSchema: z.ZodObject<{
                 env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
             }, z.core.$strict>;
         }, z.core.$strict>]>>>;
+        launch: z.ZodOptional<z.ZodObject<{
+            skipPermissions: z.ZodOptional<z.ZodBoolean>;
+            remoteControl: z.ZodOptional<z.ZodBoolean>;
+            provider: z.ZodOptional<z.ZodString>;
+            headroom: z.ZodOptional<z.ZodBoolean>;
+            trackUsage: z.ZodOptional<z.ZodBoolean>;
+            claudeVersion: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
         $schema: z.ZodOptional<z.ZodString>;
         extends: z.ZodOptional<z.ZodArray<z.ZodString>>;
         categories: z.ZodOptional<z.ZodPipe<z.ZodObject<{
@@ -427,14 +443,6 @@ declare const DirectoryRulesSchema: z.ZodObject<{
             knowledge?: boolean | undefined;
             settings?: boolean | undefined;
         }>>>;
-        launch: z.ZodOptional<z.ZodObject<{
-            skipPermissions: z.ZodOptional<z.ZodBoolean>;
-            remoteControl: z.ZodOptional<z.ZodBoolean>;
-            provider: z.ZodOptional<z.ZodString>;
-            headroom: z.ZodOptional<z.ZodBoolean>;
-            trackUsage: z.ZodOptional<z.ZodBoolean>;
-            claudeVersion: z.ZodOptional<z.ZodString>;
-        }, z.core.$strict>>;
         path: z.ZodString;
         configProfile: z.ZodOptional<z.ZodString>;
         identity: z.ZodOptional<z.ZodString>;
@@ -462,6 +470,14 @@ declare const PortableConfigSchema: z.ZodObject<{
             env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
         }, z.core.$strict>;
     }, z.core.$strict>]>>>;
+    launch: z.ZodOptional<z.ZodObject<{
+        skipPermissions: z.ZodOptional<z.ZodBoolean>;
+        remoteControl: z.ZodOptional<z.ZodBoolean>;
+        provider: z.ZodOptional<z.ZodString>;
+        headroom: z.ZodOptional<z.ZodBoolean>;
+        trackUsage: z.ZodOptional<z.ZodBoolean>;
+        claudeVersion: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
     $schema: z.ZodOptional<z.ZodString>;
     extends: z.ZodOptional<z.ZodArray<z.ZodString>>;
     categories: z.ZodOptional<z.ZodPipe<z.ZodObject<{
@@ -477,14 +493,6 @@ declare const PortableConfigSchema: z.ZodObject<{
         knowledge?: boolean | undefined;
         settings?: boolean | undefined;
     }>>>;
-    launch: z.ZodOptional<z.ZodObject<{
-        skipPermissions: z.ZodOptional<z.ZodBoolean>;
-        remoteControl: z.ZodOptional<z.ZodBoolean>;
-        provider: z.ZodOptional<z.ZodString>;
-        headroom: z.ZodOptional<z.ZodBoolean>;
-        trackUsage: z.ZodOptional<z.ZodBoolean>;
-        claudeVersion: z.ZodOptional<z.ZodString>;
-    }, z.core.$strict>>;
     configProfile: z.ZodOptional<z.ZodString>;
     identity: z.ZodOptional<z.ZodString>;
     when: z.ZodOptional<z.ZodObject<{
@@ -700,6 +708,8 @@ interface LayoutPaths {
     readonly frontdoorCaKeyFile: string;
     /** Directory of combined CA bundles: a parent environment's own NODE_EXTRA_CA_CERTS (for a routed child) or HEADROOM_CA_BUNDLE (for the headroom daemon) file plus the front door's CA, one file per distinct combination, for processes that must keep trusting both. */
     readonly frontdoorCaBundlesDir: string;
+    /** Path to the Sign in with ChatGPT file (the host id and, once signed in, the grant, mode 0600): whoever can read it can spend the person's ChatGPT plan until it is signed out. */
+    readonly chatgptSignInFile: string;
     /** Path to the front door's state.json: its supervisor pid, its port, and the sticky port it last served on. */
     readonly frontdoorStateFile: string;
     /** Path to the exclusive-create marker guarding "who spawns the front-door supervisor" so concurrent launches start at most one. */
@@ -3144,6 +3154,11 @@ interface RunDoctorParams {
     readonly installedClaudeVersions?: readonly string[];
     /** Where cached credentials live. Omit to leave a credential cache's age out of the identity and provider findings; with it, a block that caches reports whether it holds an entry, how old it is and whether it has expired, never the token. */
     readonly credentialCache?: CredentialCacheEnv;
+    /** The Sign in with ChatGPT file. Omit to leave it out of the findings; with it, a codex provider whose `codex.login` is `chatgpt-sign-in` warns when there is no usable sign-in to spend. */
+    readonly chatgptSignIn?: {
+        readonly path: string;
+        readonly raw: string | undefined;
+    };
     readonly identities: readonly DoctorIdentityInput[];
     readonly configProfiles: readonly DoctorConfigProfileInput[];
     readonly providers: readonly DoctorProviderInput[];
@@ -3337,6 +3352,111 @@ declare const UsageSnapshotSchema: z.ZodObject<{
 }, z.core.$strict>;
 type UsageSnapshot = z.infer<typeof UsageSnapshotSchema>;
 
+/**
+ * The Zod schemas of the door's event backbone: the envelope every source-tagged event carries, the source filter the subscription takes, and the launch lifecycle's own payload family. The backbone's TypeScript shapes in `eventHub.ts` and `launchEvents.ts` stay the implementations' types; these schemas are what the typed API's contract validates through, and because the backbone's publishers produce those interfaces' values, a drift between a schema and its interface fails the API's own output validation (exercised by its tests) rather than shipping silently. This module deliberately imports nothing from oRPC: it is a plain Zod leaf, so the backbone and its publishers can share it without depending on the API layer.
+ */
+/** The source tag the Remote Control client stream's events carry on the backbone: the first publisher, wrapped rather than rewritten, so its own surfaces keep their shapes untouched. */
+declare const DOOR_EVENT_SOURCE_RC = "rc";
+/** The source tag every launch lifecycle event carries: the registry's own register, prune and end moments, the first publisher the door itself owns. */
+declare const LAUNCH_EVENT_SOURCE = "launch";
+/** One event on the door's backbone, exactly as the subscription yields it: the source that published it, the sequence the backbone assigned that source, and the publisher's own payload carried verbatim for the consumer to narrow. */
+declare const DoorEventSchema: z.ZodObject<{
+    source: z.ZodString;
+    sequence: z.ZodNumber;
+    payload: z.ZodUnknown;
+}, z.core.$strict>;
+/** One event on the backbone, as the TypeScript every in-process consumer handles it (the schema's own inferred type, so the two cannot drift). */
+type DoorEvent = z.output<typeof DoorEventSchema>;
+/**
+ * The query the backbone's subscription takes: optionally named sources, every source when omitted. An empty list is refused rather than read as "everything" or as "nothing", because a caller building it programmatically has almost certainly failed to append, and silently streaming no events at all is the one answer that would never be noticed.
+ */
+declare const DoorEventSourceQuerySchema: z.ZodObject<{
+    sources: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strict>;
+/**
+ * One launch lifecycle event: what the session registry already records (a launch registering, a capability pruned because its launcher died, a session ending by its launcher's own exit hook), observed at the tick that saw it. `startedAt` is the registry record's own value; `observedAt` is when the door observed the change, which is the tick, not the change itself.
+ */
+declare const LaunchLifecycleEventSchema: z.ZodObject<{
+    kind: z.ZodEnum<{
+        registered: "registered";
+        pruned: "pruned";
+        ended: "ended";
+    }>;
+    pid: z.ZodNumber;
+    startedAt: z.ZodNumber;
+    observedAt: z.ZodNumber;
+}, z.core.$strict>;
+/** One launch lifecycle event, as the TypeScript the publisher emits and its consumers handle. */
+type LaunchLifecycleEvent = z.output<typeof LaunchLifecycleEventSchema>;
+
+/**
+ * The door's event backbone: the publisher/subscriber machinery the Remote Control client stream's fan-out first proved, generalised so any door-wide source can publish and any consumer can subscribe once instead of each source growing its own channel. A publisher registers under a source tag and publishes payloads; the backbone stamps each event with its source's own monotonic sequence and delivers to every matching subscriber synchronously, in publication order. A source that carries its own ordering on the wire (the Remote Control envelope's per-session `sequence_num`, the number its resume rule resumes after) keeps it inside the payload, verbatim: the backbone's sequence is deliberately not any protocol's number.
+ *
+ * The Remote Control client stream is the first publisher, through `rcFanoutOnDoorHub` below: the wrap publishes every event the fan-out is handed onto the backbone beside the fan-out's own delivery, and moves nothing about how Remote Control events flow, so the fan-out's existing subscribers (the tracker's filing rides the same publish, the typed API's subscription and the watch verb read the same subscribe) never know the backbone exists. The launch lifecycle is the first publisher the door itself owns (see `launchEvents.ts`).
+ *
+ * Slow consumers are bounded where the backbone bridges its synchronous publish to a pull: `stream` holds at most `DOOR_EVENT_BUFFER_EVENTS` events per subscriber and drops the oldest past that, whose absence the consumer detects by the gap it leaves in the source's sequence, the same contract the Remote Control subscription's bridge keeps. Everything here is in memory only and dies with the door process; the backbone holds no replay, so a subscriber that arrives late simply does not see earlier events.
+ */
+/**
+ * How many events one stream subscriber's bridge holds while the consumer behind it has not pulled them. Not a fresh number: it is the bound oRPC's own `EventPublisher` documents as its default for exactly this slow-consumer case (a buffer without one grows without limit), and a full buffer drops the oldest event, whose absence a consumer detects by the gap it leaves in the sequence numbers.
+ */
+declare const DOOR_EVENT_BUFFER_EVENTS = 100;
+/** One registered source: the tag its events carry and the publish call the source owns. */
+interface DoorEventPublisher {
+    /** The source's tag, the name a subscriber's filter names. */
+    readonly source: string;
+    /** Publishes one event: stamps the source's next sequence and delivers it to every matching subscriber synchronously, in publication order. */
+    readonly publish: (payload: unknown) => void;
+}
+/** The pull side of one subscription: a bounded bridge from the backbone's synchronous publish to a consumer that asks for events one at a time. */
+interface DoorEventStream {
+    /**
+     * Resolves the next event the bridge holds, waiting for one to arrive when it holds none, and resolves done once the stream is closed and drained. Serves one pull at a time: a caller that pulls concurrently forfeits the earlier pull's wake, so the contract is a serial loop (the shape every consumer of this type, the typed API's subscription included, already has).
+     */
+    readonly next: () => Promise<IteratorResult<DoorEvent>>;
+    /** Stops the delivery: detaches from the backbone and resolves a waiting pull (or the next one) with done. The buffer's contents are abandoned, not delivered. */
+    readonly close: () => void;
+}
+/** The door's event backbone. One per door process; everything it holds dies with it. */
+interface DoorEventHub {
+    /**
+     * Registers one source and returns its publisher. Idempotent in the tag: a second registration of the same name publishes through the same sequence counter, so two handles of one source cannot split its ordering. The set of registered names is fixed when the door's assembly finishes, which is what the subscription's filter validation reads.
+     */
+    readonly publisher: (source: string) => DoorEventPublisher;
+    /** Adds one listener, told every event whose source it matches; `undefined` listens to every source. Returns the detach function. */
+    readonly subscribe: (sources: readonly string[] | undefined, listener: (event: DoorEvent) => void) => () => void;
+    /** Opens one pull subscription over the backbone with the bounded drop-oldest bridge; `undefined` subscribes to every source. */
+    readonly stream: (sources: readonly string[] | undefined) => DoorEventStream;
+    /** Every registered source tag, sorted, as the subscription's filter validation names them. */
+    readonly sources: () => readonly string[];
+}
+/** Creates the backbone: plain synchronous listener sets, one per source plus one for every-source listeners, and a monotonic sequence counter per source. */
+declare function createDoorEventHub(): DoorEventHub;
+/**
+ * Wraps one Remote Control fan-out so the client read stream becomes the backbone's first publisher: the stream hub the wrap is handed to publishes through it, every event reaching the fan-out exactly as before (its subscribers, the tracker's filing included, are served first) and the backbone beside it, source-tagged `rc` with the backbone's own sequence while the envelope's per-session `sequence_num` rides inside the payload verbatim. Subscribing through the wrap is the fan-out's own subscribe, untouched, so the Remote Control surfaces that read it keep their session filtering and their shapes.
+ */
+declare function rcFanoutOnDoorHub(fanout: RcEventFanout, hub: DoorEventHub): RcEventFanout;
+
+/**
+ * The door-wide events surface of the typed API: `events.subscribe`, the generalisation of `rc.subscribe`'s pattern from one source to the backbone's every source. A consumer (a statusline, a watchdog, an automation) presents the same per-generation owner-only control token, asks for every source or names the ones it wants, and receives one stream of source-tagged events, SSE-framed by oRPC's event iterator with the backbone's per-source sequence as the SSE event id, so a slow consumer that had events dropped by its bounded bridge sees the gap in that number exactly as a Remote Control subscriber sees one in the envelope's own.
+ *
+ * The router this module builds is mounted by `controlApi.ts` beside the Remote Control and control-plane routers on the one prefix the provider listener already serves, so every surface of the door's typed API shares one token gate, one body cap and one transport.
+ */
+/** Everything the events surface needs: the token every typed door API procedure demands, and the backbone whose events the subscription yields. */
+interface DoorEventsApiDeps {
+    /** This generation's control token: the same value the Remote Control router checks, since one mount serves both. */
+    readonly expectedToken: string;
+    /** The door's event backbone: the publisher registry every source registers on and this subscription reads. */
+    readonly events: DoorEventHub;
+}
+/** Builds the events router: one streaming procedure behind the control-token middleware. */
+declare function createEventsApiRouter(deps: DoorEventsApiDeps): {
+    events: {
+        subscribe: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
+            sources: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
+        }, zod_v4_core.$strict>, any, Record<never, never>, Record<never, never>>;
+    };
+};
+
 /** The record held in one front-door session-registry file: the launcher's pid plus the per-launch capability token its child presents on every request. */
 declare const FrontDoorSessionSchema: z.ZodObject<{
     pid: z.ZodNumber;
@@ -3395,7 +3515,7 @@ declare function formatFrontDoorStatus(status: FrontDoorStatus, caCertPath: stri
  * - `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.
  *
- * Read-only by design: identity, configuration-profile, provider, pool and directory-rule management stay CLI-side, and adding writes over this mount is a decision of its own rather than a gap here. `createDoorApiNodeHandler` mounts these routers beside the Remote Control router on the one prefix the provider listener already serves, so a consumer dials one address with one token for the whole door.
+ * Read-only by design: identity, configuration-profile, provider, pool and directory-rule management stay CLI-side, and adding writes over this mount is a decision of its own rather than a gap here. `createDoorApiNodeHandler` mounts these routers and the door-wide `events.subscribe` router beside the Remote Control router on the one prefix the provider listener already serves, so a consumer dials one address with one token for the whole door.
  */
 /** Everything the control-plane procedures need, injected so they serve against fakes in tests exactly as the door's real wiring serves against this machine. */
 interface ControlApiDeps {
@@ -3883,11 +4003,16 @@ declare function createControlApiRouter(deps: ControlApiDeps): {
 type ControlApiRouter = ReturnType<typeof createControlApiRouter>;
 /** The control plane alone as a client sees it: every call presents the control token, over TLS trusting only the CA file the door's own state names. */
 type ControlApiClient = RouterClient<ControlApiRouter>;
-/** Everything the door's whole typed API needs: the Remote Control operations and the control-plane reads, one deps object because one mount serves them under one token. */
-interface DoorApiDeps extends RcApiDeps, ControlApiDeps {
+/** Everything the door's whole typed API needs: the Remote Control operations, the control-plane reads and the door-wide event stream, one deps object because one mount serves them under one token. */
+interface DoorApiDeps extends RcApiDeps, ControlApiDeps, DoorEventsApiDeps {
 }
-/** Builds the door's whole typed API: the Remote Control router and the control-plane routers beside it, one object for the one handler the provider listener mounts. */
+/** Builds the door's whole typed API: the Remote Control router, the control-plane routers and the events router beside them, one object for the one handler the provider listener mounts. */
 declare function createDoorApiRouter(deps: DoorApiDeps): {
+    events: {
+        subscribe: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, zod.ZodObject<{
+            sources: zod.ZodOptional<zod.ZodArray<zod.ZodString>>;
+        }, zod_v4_core.$strict>, any, Record<never, never>, Record<never, never>>;
+    };
     usage: {
         list: _orpc_server.DecoratedProcedure<_orpc_server.MergedInitialContext<DoorApiContext & Record<never, never>, DoorApiContext, DoorApiContext>, any, Schema<unknown, unknown>, zod.ZodObject<{
             snapshots: zod.ZodReadonly<zod.ZodArray<zod.ZodObject<{
@@ -4673,6 +4798,21 @@ declare const DoctorRunOutputSchema: z.ZodObject<{
     }, z.core.$strict>>>;
 }, z.core.$strict>;
 
+/**
+ * The launch lifecycle publisher: the door's first event source of its own, turning the session registry the supervisor already reads each tick into source-tagged backbone events. A launch registering, a capability pruned because its launcher died, and a session ending by its launcher's own exit hook are all registry facts before they are events, which is why the publisher emits nothing of its own: it is fed the tick's listing and the pids the prune removed, and publishes the diff against the previous tick.
+ *
+ * The first observation establishes the baseline and emits nothing, because a session the registry already held registered before this door generation began and the door never observed the moment; the backbone holds no replay in any case. Within one observation the departures publish before the arrivals (the prune the tick performs, then the ends the tick discovered, then the registrations), each group in the registry's own pid order, the one ordering the facts genuinely carry; anything finer happened between ticks and no claim about it would be honest.
+ */
+/** Everything the launch lifecycle publisher needs: the backbone it publishes on and the clock its events are observed at. */
+interface LaunchEventPublisher {
+    /**
+     * Reports one tick's registry facts: the sessions the tick's listing saw (taken before the prune, so a pruned launch's record is still there to name its start time) and the pids the tick's prune removed. Publishes the diff against the previous observation; the first observation is the baseline and publishes nothing.
+     */
+    readonly observe: (sessions: readonly FrontDoorSessionSummary[], pruned: readonly number[]) => void;
+}
+/** Creates the launch lifecycle publisher. One per door process, fed by the supervisor's tick. */
+declare function createLaunchEventPublisher(hub: DoorEventHub, now: () => number): LaunchEventPublisher;
+
 /**
  * The self-hosted Remote Control service: the door serving, locally, the CCR surface it normally only observes (ExaDev/agent-shim#207). When the mode is on, a Claude Code session activates Remote Control against this surface and is controlled through it with no Anthropic credential anywhere: the door answers the session family itself instead of piping it to the real API host, so the `cse_` sessions, their sequence numbers, their worker and client streams and their event writes all live on this machine.
  *
@@ -4847,6 +4987,10 @@ interface FrontDoorSupervisorPorts {
      * Stops the Remote Control stream hub: persists every live attachment's sequence cursor synchronously, then frees the dials. Called exactly once on every exit the supervisor owns, after every listener it started is down (a live listener could still settle an observed Remote Control exchange, and the reconcile that follows would re-attach a stream the close had just ended) and before the final state write and the process's exit.
      */
     readonly closeRcStreamHub: () => void;
+    /**
+     * Reports one tick's session-registry facts to the door's event backbone: the sessions the tick's listing saw (taken before the prune, so a pruned launch's record is still there to name its start time) and the pids the tick's prune removed. The launch lifecycle publisher turns the diff between ticks into source-tagged events; the listing is also this loop's own idle input, so the two read one fact instead of two.
+     */
+    readonly observeLaunchRegistry: (sessions: readonly FrontDoorSessionSummary[], pruned: readonly number[]) => void;
     readonly log: (line: string) => void;
 }
 /** Options for `runFrontDoorSupervisor`. */
@@ -5540,5 +5684,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, DirectoryRuleAlreadyExistsError, DirectoryRuleMissingTargetError, DirectoryRuleNotFoundError, DirectoryRuleSchema, DirectoryRulesSchema, DoctorFindingSchema, DoctorRunOutputSchema, EXIT_FAILURE, EXIT_USAGE, EffectiveWindowSchema, EntryValueSchema, FARM_MANIFEST_FILENAME, FrontDoorSessionStatusSchema, FrontDoorSessionsOutputSchema, FrontDoorStartError, FrontDoorStateSchema, FrontDoorStatusOutputSchema, GlobalConfigSchema, HeadroomSocketTargetSchema, HeadroomStartError, IdentityAlreadyExistsError, IdentityNotFoundError, IdentitySchema, InvalidCategoryNameError, InvalidIdentityNameError, InvalidProviderNameError, LaunchRefusedError, LegacyProviderFileError, PROMPT_CACHE_TTL_MS, PlanClassSchema, PoolNameSchema, PoolNotFoundError, PoolPickReportSchema, PoolSchema, PortableConfigSchema, ProfileAlreadyExistsError, ProfileNotFoundError, ProviderAlreadyExistsError, ProviderKindMismatchError, ProviderNotFoundError, ProviderSchema, RC_IDLE_EXPIRY_MS, RC_ORPC_PATH_PREFIX, RC_PENDING_DEADLINE_MS, RC_PERMISSION_MODES, RC_REQUEST_PARSE_CAP_BYTES, RC_SELF_HOST_ENV, RC_SELF_HOST_KEEPALIVE_MS, RC_SELF_HOST_RECORD_DIR, RC_SELF_HOST_RECORD_FILE, RC_SELF_HOST_RETENTION_MS, RC_SELF_HOST_SCOPE_LIST, RC_SELF_HOST_WORKER_JWT_TTL_SECONDS, RC_SESSIONS_PATH_PREFIX, RC_STREAM_BACKOFF_MS, ROUTED_PATH_PREFIX, RcPermissionModeSchema, RcStreamEnvelopeSchema, RcStreamEventSchema, UsageError, UsageListOutputSchema, UsageSnapshotError, UsageSnapshotSchema, UsageWindowsInputSchema, UsageWindowsOutputSchema, WhenSchema, addDirectoryRule, addIdentity, addPool, addProvider, answerRcControlRequest, buildEntryFacts, buildLayoutPaths, buildRcControlResponsePayload, buildRcEventWriteBody, buildRcInterruptPayload, buildRcSetModelPayload, buildRcSetPermissionModePayload, buildRcUserMessagePayload, carryOver, checkReportHasWarnings, checkReportToJson, collectCheckReport, collectDoctorReport, collectFrontDoorStatus, collectPoolPick, createControlApiRouter, createDoorApiNodeHandler, createDoorApiRouter, createLeafCache, createProfile, createRcApiNodeHandler, createRcApiRouter, createRcControlHandler, createRcCredentialStore, createRcEventFanout, createRcSelfHostSurface, createRcSessionTracker, createRcStreamHub, createSseParser, describeProviderEndpoint, detectAmbientCredential, doorApiAuth, doorApiNodeHandlerOf, effectiveWindow, ensureCa, ensureFrontDoor, ensureHeadroom, evaluateAmbientCredentialGuard, evaluateWhen, formatAmbientCredentialGuardMessage, formatCheckReport, formatDoctorReport, formatFrontDoorStatus, forwardableHeaders, frontDoorApiClient, frontDoorApiLink, frontDoorRcApiClient, frontDoorRcControl, generateCa, headroomSocketTarget, identityExists, injectRcUserMessage, interruptRcSession, isIdentityDirectoryName, isInterceptedHost, isRcPermissionMode, lateRcEventDial, lateRcStreamDial, listDirectoryRules, listIdentities, listProfiles, listProviders, listUsageSnapshots, matchBranch, mintLeaf, mintRcSelfHostCredential, observingRoutedRoute, parseConnectTarget, parseRcStreamEnvelope, planOf, prepareClaudeLaunch, prepareLaunch, profileExists, providerExists, rankPool, rcEventWriteResultFromAnswer, rcObserverAsPassthrough, rcSelfHostFromEnv, readActiveIdentity, readDirectoryRules, readFarmManifest, readGlobalConfig, readIdentity, readPools, readProfile, readProvider, readRcSelfHostRecord, readUsageSnapshot, realConnectCertStore, realConnectEffects, realRcControlTransport, realRcEventDial, realRcStreamDial, recoverFarm, recoveryDiagnostics, removeDirectoryRule, removeIdentity, removePool, removeProfile, removeProvider, requirePool, resolveAgentShimHome, resolveClaudeHome, resolveDecisions, resolveLayoutPaths, resolveSupervisorConfig, resyncFarm, runCheck, runDoctor, runFrontDoorSupervisor, runLauncher, runSupervisor, servedByPipeline, setAllowAmbientCredential, setDefaultConfigProfile, setGlobalDefaultProfile, setIdentityCredential, setPool, setProfileCategories, setProfileEntries, setProfileLaunchFlags, setProfileMetadata, setRcSessionModel, setRcSessionPermissionMode, snapshotPath, spawnClaude, startConnectServer, topLevelNames, updateDirectoryRule, updateProvider, useIdentity, writeDirectoryRules };
-export type { AddDirectoryRuleOptions, AddProviderInput, AmbientCredentialDetection, AmbientCredentialGuardResult, AmbientCredentialVar, BuildEntryFactsParams, CaMaterial, Candidate, CarryOverParams, CarryOverResult, CategoryMap, CheckReport, CheckReportJson, CollectCheckReportParams, CollectDoctorReportParams, CompiledRule, ConditionContext, ConfigProfile, ConnectCertStore, ConnectEffects, ConnectLimits, ConnectLocalSurface, ConnectServerConfig, ConnectServerHandle, ConnectTarget, ControlApiClient, ControlApiDeps, ControlApiRouter, Credential, CredentialSource, Decision, Diagnostic, DirectoryRule, DirectoryRules, DoctorReport, DoorApiClient, DoorApiContext, DoorApiDeps, DoorApiRouter, EffectiveWindow, EliminatedRule, EnsureFrontDoorPorts, EnsureHeadroomPorts, EntryFact, EntryFacts, EntryValue, EvaluateAmbientCredentialGuardParams, FlattenedCascade, FrontDoorRcControl, FrontDoorSessionStatus, FrontDoorStatus, FrontDoorSupervisorPorts, GlobalConfig, HeadroomSupervisorConfig, Identity, IdentityCredentialChange, IdentityListEntry, IdentityListing, InjectedCredential, LaunchPlan, Layer, LayerId, LayoutPaths, LeafCert, PlanClass, Pool, PoolMember, PoolPickReport, PoolRanking, PortableConfig, PrepareClaudeLaunchOptions, PrepareLaunchParams, ProfileListEntry, Provider, ProviderListEntry, RankPoolInput, RcAnswerDecision, RcAnswerDeps, RcApiClient, RcApiDeps, RcApiRouter, RcControlAnswer, RcControlHandlerDeps, RcControlRequestDeps, RcControlTransport, RcCredentialStore, RcDialAnswer, RcDialTarget, RcEventDial, RcEventFanout, RcEventWriteResult, RcExchangeObserver, RcInjectDeps, RcObservedCredential, RcObservedRequest, RcPendingRequestSummary, RcPermissionMode, RcPresenceAnswer, RcSelfHostCredentialRecord, RcSelfHostDeps, RcSelfHostMintResult, RcSelfHostSurface, RcSessionStatus, RcSessionSummary, RcSessionTracker, RcSessionTrackerDeps, RcStreamAnswer, RcStreamDial, RcStreamEnvelope, RcStreamEvent, RcStreamHub, RcStreamHubDeps, 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_IDLE_EXPIRY_MS, RC_ORPC_PATH_PREFIX, RC_PENDING_DEADLINE_MS, RC_PERMISSION_MODES, RC_REQUEST_PARSE_CAP_BYTES, RC_SELF_HOST_ENV, RC_SELF_HOST_KEEPALIVE_MS, RC_SELF_HOST_RECORD_DIR, RC_SELF_HOST_RECORD_FILE, RC_SELF_HOST_RETENTION_MS, RC_SELF_HOST_SCOPE_LIST, RC_SELF_HOST_WORKER_JWT_TTL_SECONDS, RC_SESSIONS_PATH_PREFIX, RC_STREAM_BACKOFF_MS, ROUTED_PATH_PREFIX, RcPermissionModeSchema, RcStreamEnvelopeSchema, RcStreamEventSchema, UsageError, UsageListOutputSchema, UsageSnapshotError, UsageSnapshotSchema, UsageWindowsInputSchema, UsageWindowsOutputSchema, WhenSchema, addDirectoryRule, addIdentity, addPool, addProvider, answerRcControlRequest, buildEntryFacts, buildLayoutPaths, buildRcControlResponsePayload, buildRcEventWriteBody, buildRcInterruptPayload, buildRcSetModelPayload, buildRcSetPermissionModePayload, buildRcUserMessagePayload, carryOver, checkReportHasWarnings, checkReportToJson, collectCheckReport, collectDoctorReport, collectFrontDoorStatus, collectPoolPick, createControlApiRouter, createDoorApiNodeHandler, createDoorApiRouter, createDoorEventHub, createEventsApiRouter, createLaunchEventPublisher, createLeafCache, createProfile, createRcApiNodeHandler, createRcApiRouter, createRcControlHandler, createRcCredentialStore, createRcEventFanout, createRcSelfHostSurface, createRcSessionTracker, createRcStreamHub, createSseParser, describeProviderEndpoint, detectAmbientCredential, doorApiAuth, doorApiNodeHandlerOf, effectiveWindow, ensureCa, ensureFrontDoor, ensureHeadroom, evaluateAmbientCredentialGuard, evaluateWhen, formatAmbientCredentialGuardMessage, formatCheckReport, formatDoctorReport, formatFrontDoorStatus, forwardableHeaders, frontDoorApiClient, frontDoorApiLink, frontDoorRcApiClient, frontDoorRcControl, generateCa, headroomSocketTarget, identityExists, injectRcUserMessage, interruptRcSession, isIdentityDirectoryName, isInterceptedHost, isRcPermissionMode, lateRcEventDial, lateRcStreamDial, listDirectoryRules, listIdentities, listProfiles, listProviders, listUsageSnapshots, matchBranch, mintLeaf, mintRcSelfHostCredential, observingRoutedRoute, parseConnectTarget, parseRcStreamEnvelope, planOf, prepareClaudeLaunch, prepareLaunch, profileExists, providerExists, rankPool, rcEventWriteResultFromAnswer, rcFanoutOnDoorHub, rcObserverAsPassthrough, rcSelfHostFromEnv, readActiveIdentity, readDirectoryRules, readFarmManifest, readGlobalConfig, readIdentity, readPools, readProfile, readProvider, readRcSelfHostRecord, readUsageSnapshot, realConnectCertStore, realConnectEffects, realRcControlTransport, realRcEventDial, realRcStreamDial, recoverFarm, recoveryDiagnostics, removeDirectoryRule, removeIdentity, removePool, removeProfile, removeProvider, requirePool, resolveAgentShimHome, resolveClaudeHome, resolveDecisions, resolveLayoutPaths, resolveSupervisorConfig, resyncFarm, runCheck, runDoctor, runFrontDoorSupervisor, runLauncher, runSupervisor, servedByPipeline, setAllowAmbientCredential, setDefaultConfigProfile, setGlobalDefaultProfile, setIdentityCredential, setPool, setProfileCategories, setProfileEntries, setProfileLaunchFlags, setProfileMetadata, setRcSessionModel, setRcSessionPermissionMode, snapshotPath, spawnClaude, startConnectServer, topLevelNames, updateDirectoryRule, updateProvider, useIdentity, writeDirectoryRules };
+export type { AddDirectoryRuleOptions, AddProviderInput, AmbientCredentialDetection, AmbientCredentialGuardResult, AmbientCredentialVar, BuildEntryFactsParams, CaMaterial, Candidate, CarryOverParams, CarryOverResult, CategoryMap, CheckReport, CheckReportJson, CollectCheckReportParams, CollectDoctorReportParams, CompiledRule, ConditionContext, ConfigProfile, ConnectCertStore, ConnectEffects, ConnectLimits, ConnectLocalSurface, ConnectServerConfig, ConnectServerHandle, ConnectTarget, ControlApiClient, ControlApiDeps, ControlApiRouter, Credential, CredentialSource, Decision, Diagnostic, DirectoryRule, DirectoryRules, DoctorReport, DoorApiClient, DoorApiContext, DoorApiDeps, DoorApiRouter, DoorEvent, DoorEventHub, DoorEventPublisher, DoorEventStream, DoorEventsApiDeps, EffectiveWindow, EliminatedRule, EnsureFrontDoorPorts, EnsureHeadroomPorts, EntryFact, EntryFacts, EntryValue, EvaluateAmbientCredentialGuardParams, FlattenedCascade, FrontDoorRcControl, FrontDoorSessionStatus, FrontDoorStatus, FrontDoorSupervisorPorts, GlobalConfig, HeadroomSupervisorConfig, Identity, IdentityCredentialChange, IdentityListEntry, IdentityListing, InjectedCredential, LaunchEventPublisher, LaunchLifecycleEvent, LaunchPlan, Layer, LayerId, LayoutPaths, LeafCert, PlanClass, Pool, PoolMember, PoolPickReport, PoolRanking, PortableConfig, PrepareClaudeLaunchOptions, PrepareLaunchParams, ProfileListEntry, Provider, ProviderListEntry, RankPoolInput, RcAnswerDecision, RcAnswerDeps, RcApiClient, RcApiDeps, RcApiRouter, RcControlAnswer, RcControlHandlerDeps, RcControlRequestDeps, RcControlTransport, RcCredentialStore, RcDialAnswer, RcDialTarget, RcEventDial, RcEventFanout, RcEventWriteResult, RcExchangeObserver, RcInjectDeps, RcObservedCredential, RcObservedRequest, RcPendingRequestSummary, RcPermissionMode, RcPresenceAnswer, RcSelfHostCredentialRecord, RcSelfHostDeps, RcSelfHostMintResult, RcSelfHostSurface, RcSessionStatus, RcSessionSummary, RcSessionTracker, RcSessionTrackerDeps, RcStreamAnswer, RcStreamDial, RcStreamEnvelope, RcStreamEvent, RcStreamHub, RcStreamHubDeps, 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.15.0",
+  "version": "8.17.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>",