agent-shim 8.6.0 → 8.8.0

package/dist/types/index.d.ts

@@ -2049,6 +2049,73 @@ interface RunFrontDoorSupervisorOptions {
  */
 declare function runFrontDoorSupervisor(idleShutdownMinutes: number, ports: FrontDoorSupervisorPorts, options?: RunFrontDoorSupervisorOptions): Promise<number>;
 
+/** One routed request, appended to the usage log when its response has finished. */
+declare const UsageRecordSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    at: z.ZodISODateTime;
+    identity: z.ZodOptional<z.ZodString>;
+    provider: z.ZodString;
+    sessionId: z.ZodOptional<z.ZodString>;
+    project: z.ZodOptional<z.ZodString>;
+    route: z.ZodString;
+    method: z.ZodString;
+    endpoint: z.ZodString;
+    model: z.ZodOptional<z.ZodString>;
+    status: z.ZodNumber;
+    latencyMs: z.ZodNumber;
+    durationMs: z.ZodNumber;
+    outcome: z.ZodEnum<{
+        completed: "completed";
+        aborted: "aborted";
+    }>;
+    usage: z.ZodOptional<z.ZodObject<{
+        inputTokens: z.ZodOptional<z.ZodNumber>;
+        outputTokens: z.ZodOptional<z.ZodNumber>;
+        cacheCreationInputTokens: z.ZodOptional<z.ZodNumber>;
+        cacheReadInputTokens: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strict>>;
+    rateLimitHeaders: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    limit: z.ZodOptional<z.ZodObject<{
+        kind: z.ZodEnum<{
+            "rate-limited": "rate-limited";
+            "quota-exhausted": "quota-exhausted";
+        }>;
+        retryAfterSeconds: z.ZodOptional<z.ZodNumber>;
+        resetAt: z.ZodOptional<z.ZodISODateTime>;
+        window: z.ZodOptional<z.ZodString>;
+        evidence: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    requestId: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type UsageRecord = z.infer<typeof UsageRecordSchema>;
+/** One quota window from Anthropic's unified rate-limit headers. */
+declare const QuotaWindowSchema: z.ZodObject<{
+    utilization: z.ZodOptional<z.ZodNumber>;
+    resetsAt: z.ZodOptional<z.ZodISODateTime>;
+    status: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type QuotaWindow = z.infer<typeof QuotaWindowSchema>;
+/**
+ * The account fields copied from an identity's stored Claude login (`oauthAccount` in the identity's `.claude.json`): who the account is and which plan and tier it is on. Never the token, which Claude Code keeps elsewhere. Each field is present only when the stored login has it; a setup-token identity has no profile scope and so none of them (see issue #44).
+ */
+declare const AccountMetadataSchema: z.ZodObject<{
+    accountUuid: z.ZodOptional<z.ZodString>;
+    emailAddress: z.ZodOptional<z.ZodString>;
+    displayName: z.ZodOptional<z.ZodString>;
+    organizationUuid: z.ZodOptional<z.ZodString>;
+    organizationName: z.ZodOptional<z.ZodString>;
+    organizationType: z.ZodOptional<z.ZodString>;
+    organizationRole: z.ZodOptional<z.ZodString>;
+    workspaceRole: z.ZodOptional<z.ZodString>;
+    billingType: z.ZodOptional<z.ZodString>;
+    seatTier: z.ZodOptional<z.ZodString>;
+    organizationRateLimitTier: z.ZodOptional<z.ZodString>;
+    userRateLimitTier: z.ZodOptional<z.ZodString>;
+    hasExtraUsageEnabled: z.ZodOptional<z.ZodBoolean>;
+    subscriptionCreatedAt: z.ZodOptional<z.ZodString>;
+    accountCreatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type AccountMetadata = z.infer<typeof AccountMetadataSchema>;
 /**
  * The latest state for one identity, rewritten atomically after each recorded response: the snapshot file other tools read (`~/.agent-shim/usage/snapshots/<identity>.json`) without shelling out to `agent-shim`.
  */
@@ -2145,6 +2212,175 @@ declare function readUsageSnapshot(fs: Pick<FarmFs, "readFileUtf8">, snapshotsDi
 /** Reads every identity's snapshot, by identity name. */
 declare function listUsageSnapshots(fs: UsageReadFs, snapshotsDir: string): readonly UsageSnapshot[];
 
+/** A quota window as it stands at a given instant. */
+interface EffectiveWindow {
+    /** True when the window's reset time has passed, so the recorded observation describes a window that no longer exists. */
+    readonly reset: boolean;
+    /** The fraction used: 0 for a reset window, otherwise what was last observed (a lower bound, since utilisation only rises within a window), or undefined when none was reported. */
+    readonly utilization?: number;
+    /** The reset instant, for a window that has not reset yet and reported one. */
+    readonly resetsAtMs?: number;
+    /** The window's own status, for a window that has not reset yet. */
+    readonly status?: string;
+}
+/** Reads a recorded window at `nowMs`: a window whose reset has passed is empty and carries no status, so every consumer agrees on what an old observation still means. */
+declare function effectiveWindow(window: Readonly<QuotaWindow>, nowMs: number): EffectiveWindow;
+
+/**
+ * What an account's plan means for picking it: a subscription with a capacity relative to the smallest paid tier, or an account billed by use.
+ */
+declare const PlanClassSchema: z.ZodUnion<readonly [z.ZodObject<{
+    kind: z.ZodLiteral<"subscription">;
+    capacity: z.ZodNumber;
+    recognised: z.ZodBoolean;
+    tier: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>, z.ZodObject<{
+    kind: z.ZodLiteral<"pay-per-use">;
+    tier: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>]>;
+type PlanClass = z.infer<typeof PlanClassSchema>;
+/**
+ * Classifies an account from the rate-limit tier of its stored login (`organizationRateLimitTier`, which decides the organisation's limits, then `userRateLimitTier`). The tier strings are free text on Anthropic's side, so only the shapes seen are read: a trailing `<n>x` is that multiple, a bare `pro` is 1, a `zero` tier is pay-per-use. Anything else is a subscription of unrecognised size, counted as 1 and marked so the ranking can say it guessed.
+ */
+declare function planOf(account: AccountMetadata | undefined): PlanClass;
+
+/** Anthropic's longest prompt-cache lifetime (the one-hour tier): a conversation resumed within it still has a warm cache on the account that served it, and the cache is per organisation, so it is lost by switching. */
+declare const PROMPT_CACHE_TTL_MS: number;
+/** The state a member's ranking was built from. */
+interface PoolMember {
+    readonly identity: string;
+    /** The identity's usage snapshot, when it has one. */
+    readonly snapshot?: UsageSnapshot;
+    /** Why the member's recorded state could not be read (a corrupt or newer-schema snapshot, an unreadable login file), when that is the case. */
+    readonly readError?: string;
+    readonly account?: AccountMetadata;
+    /** The member's usage-log records from the current five-hour window on. */
+    readonly records: readonly UsageRecord[];
+}
+/** The member last picked for this directory, kept so a conversation stays on the account whose prompt cache is warm. */
+interface StickyPick {
+    readonly identity: string;
+    readonly at: string;
+}
+interface RankPoolInput {
+    readonly members: readonly PoolMember[];
+    readonly nowMs: number;
+    readonly sticky?: StickyPick;
+    /** True when the launch continues or resumes a conversation, which belongs on the account it started on whatever the cache lifetime. */
+    readonly resuming: boolean;
+}
+/** In pick order. `scored` has usable quota data; `unknown` has none (never recorded, or unreadable); `pay-per-use` bills by use instead of drawing on a plan; `ineligible` is refused right now. */
+type CandidateClass = "scored" | "unknown" | "pay-per-use" | "ineligible";
+interface Candidate {
+    readonly identity: string;
+    readonly class: CandidateClass;
+    /** Plan-size-weighted remaining quota per hour until its reset: higher is more wasted if left unused. Present for `scored` only. */
+    readonly score?: number;
+    /** False when the five-hour window would run dry, at the observed pace, before it resets. A `scored` candidate that is not feasible ranks below every feasible one. */
+    readonly feasible: boolean;
+    /** When an `ineligible` candidate can be used again. */
+    readonly blockedUntilMs?: number;
+    readonly plan: PlanClass;
+    /** Human-readable facts behind the class and score, in the order they matter. */
+    readonly reasons: readonly string[];
+}
+interface PoolRanking {
+    /** Every member, best first. */
+    readonly candidates: readonly Candidate[];
+    /** The member to launch on: the best one that is not refused. Undefined when every member is refused. */
+    readonly pick?: Candidate;
+    /** When nothing can be picked, the soonest any member comes back. */
+    readonly earliestReturn?: {
+        readonly identity: string;
+        readonly atMs: number;
+    };
+}
+/**
+ * Ranks `members` for a launch.
+ *
+ * A member is `ineligible` while a window of its plan, or a refusal it last hit, still binds; it is `unknown` without recorded quota, `pay-per-use` when its usage bills by use, and otherwise `scored`. Scored members order by how much plan-size-weighted quota would expire unused per hour of runway, with any whose five-hour window would run dry at the observed pace (their own, or the person's pace on another member rescaled by plan size) placed behind those that would not. The member last picked for this directory then moves to the front if it is still usable and either the launch resumes a conversation or its prompt cache is still warm.
+ */
+declare function rankPool(input: RankPoolInput): PoolRanking;
+
+/** What `pool pick` reports: the ranking a launch from `directory` would act on right now. */
+declare const PoolPickReportSchema: z.ZodObject<{
+    pool: z.ZodString;
+    directory: z.ZodString;
+    pick: z.ZodOptional<z.ZodString>;
+    candidates: z.ZodArray<z.ZodObject<{
+        identity: z.ZodString;
+        class: z.ZodEnum<{
+            unknown: "unknown";
+            "pay-per-use": "pay-per-use";
+            scored: "scored";
+            ineligible: "ineligible";
+        }>;
+        score: z.ZodOptional<z.ZodNumber>;
+        feasible: z.ZodBoolean;
+        blockedUntil: z.ZodOptional<z.ZodISODateTime>;
+        plan: z.ZodUnion<readonly [z.ZodObject<{
+            kind: z.ZodLiteral<"subscription">;
+            capacity: z.ZodNumber;
+            recognised: z.ZodBoolean;
+            tier: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>, z.ZodObject<{
+            kind: z.ZodLiteral<"pay-per-use">;
+            tier: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>]>;
+        reasons: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    missing: z.ZodArray<z.ZodString>;
+    earliestReturn: z.ZodOptional<z.ZodObject<{
+        identity: z.ZodString;
+        at: z.ZodISODateTime;
+    }, z.core.$strict>>;
+    stickyProblem: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type PoolPickReport = z.infer<typeof PoolPickReportSchema>;
+
+/**
+ * Ranks a pool exactly as a launch from `directory` would right now, without recording a pick. Shares `rankPoolFromStore` with the launcher, so what this prints is what a launch does.
+ */
+declare function collectPoolPick(params: Readonly<{
+    paths: LayoutPaths;
+    fs: FsPort;
+    usageFs: FarmFs;
+    poolName: string;
+    pool: Pool;
+    directory: string;
+    nowMs: number;
+}>): PoolPickReport;
+
+/** Everything a `when` condition can be evaluated against, injected rather than read. */
+interface ConditionContext {
+    readonly nowMs: number;
+    /** Facts about the specific entry being decided. Absent when evaluating a rule-level condition that has no single entry (a directory rule's own `when`). */
+    readonly fact?: EntryFact;
+    /** The branch checked out at `cwd`, or undefined when `cwd` is not in a repository. */
+    readonly branch?: string;
+    /** True when the repository is in detached-HEAD state, in which case no `branch` condition can match. */
+    readonly branchDetached?: boolean;
+    readonly env: Readonly<Record<string, string | undefined>>;
+}
+/** The result of evaluating one `when` object. */
+interface WhenEvaluation {
+    readonly passed: boolean;
+    /** Which condition fields were present and evaluated. */
+    readonly checked: readonly string[];
+    /** Which of those fields did not hold. Empty when `passed` is true. */
+    readonly failed: readonly string[];
+}
+/** True when `branch` matches `pattern`. The pattern is glob-capable (`client/*`); a detached HEAD or a non-repository directory never matches. */
+declare function matchBranch(pattern: string, branch: string | undefined, detached?: boolean): boolean;
+/**
+ * Evaluates a `when` object. Every present field must hold — conditions AND together within one object.
+ *
+ * An absent condition is vacuously true, so `when: {}` passes; `agent-shim check` warns about that rather than erroring, since an empty object is more likely a half-finished edit than an intentional statement.
+ *
+ * `newerThan`, `olderThan`, and `maxSizeBytes` read the subtree-aggregated facts (`latestMtimeMs`, `totalSizeBytes`), never the entry's own inode stat: a directory's own mtime does not change when a file three levels beneath it is rewritten, and its own size is a ~4KB inode figure that says nothing about what it contains.
+ */
+declare function evaluateWhen(when: WhenCondition | undefined, context: ConditionContext): WhenEvaluation;
+
 /** Raised when the daemon cannot be brought up in time, or reports a fatal `lastError`: a launch that asked for headroom must never silently fall back to a direct connection. */
 declare class HeadroomStartError extends CliError {
     constructor(message: string);
@@ -2497,6 +2733,24 @@ interface CredentialCachePort {
     readonly write: (store: CredentialCacheStore, owner: string, entry: CachedCredential) => void;
     readonly remove: (store: CredentialCacheStore, owner: string) => void;
 }
+/**
+ * What the cache holds for one credential, without the token: whether there is an entry, how old it is, and whether it is still within the block's TTL. `expiresInMs` is absent for a block with no expiry.
+ */
+type CachedCredentialState = {
+    readonly store: CredentialCacheStore;
+    readonly status: "empty";
+}
+/** The store cannot be read here (the keychain store configured on a platform without a Keychain): reported with its reason rather than failing the whole report. */
+ | {
+    readonly store: CredentialCacheStore;
+    readonly status: "unreadable";
+    readonly reason: string;
+} | {
+    readonly store: CredentialCacheStore;
+    readonly status: "fresh" | "expired";
+    readonly ageMs: number;
+    readonly expiresInMs?: number;
+};
 
 /** What reading one `file` source found: nothing at that path, or its contents and permission bits. `mode` is undefined on a platform with no POSIX permission bits (Windows), where the looseness check cannot apply. */
 type SecretFileRead = {
@@ -2737,64 +2991,6 @@ type ConfigProfileDecisionSource =
 /** Nothing resolved a configuration profile at all. */
  | "none";
 
-/** What an account's plan means for picking it: a subscription with a capacity relative to the smallest paid tier, or an account billed by use. */
-type PlanClass = {
-    readonly kind: "subscription";
-    /** The plan's size as a multiple of the smallest subscription tier (Max 5x is 5, Max 20x is 20). */
-    readonly capacity: number;
-    /** False when the tier string named no multiplier and no tier this project knows, so `capacity` is the neutral 1 rather than a reading. */
-    readonly recognised: boolean;
-    /** The tier string the classification rests on, when the account had one. */
-    readonly tier?: string;
-} | {
-    readonly kind: "pay-per-use";
-    readonly tier?: string;
-};
-
-/** In pick order. `scored` has usable quota data; `unknown` has none (never recorded, or unreadable); `pay-per-use` bills by use instead of drawing on a plan; `ineligible` is refused right now. */
-type CandidateClass = "scored" | "unknown" | "pay-per-use" | "ineligible";
-interface Candidate {
-    readonly identity: string;
-    readonly class: CandidateClass;
-    /** Plan-size-weighted remaining quota per hour until its reset: higher is more wasted if left unused. Present for `scored` only. */
-    readonly score?: number;
-    /** False when the five-hour window would run dry, at the observed pace, before it resets. A `scored` candidate that is not feasible ranks below every feasible one. */
-    readonly feasible: boolean;
-    /** When an `ineligible` candidate can be used again. */
-    readonly blockedUntilMs?: number;
-    readonly plan: PlanClass;
-    /** Human-readable facts behind the class and score, in the order they matter. */
-    readonly reasons: readonly string[];
-}
-
-/** What `pool pick` reports: the ranking a launch from `directory` would act on right now. */
-interface PoolPickReport {
-    readonly pool: string;
-    readonly directory: string;
-    /** The member a launch would run as, absent when every member is refused. */
-    readonly pick?: string;
-    readonly candidates: readonly PoolPickCandidateView[];
-    /** Members that name an identity that does not exist; a launch skips them. */
-    readonly missing: readonly string[];
-    /** When nothing can be picked, the soonest any member returns. */
-    readonly earliestReturn?: {
-        readonly identity: string;
-        readonly at: string;
-    };
-    /** Why the last-pick record could not be read, when that is the case. */
-    readonly stickyProblem?: string;
-}
-/** One ranked member as `pool pick --json` prints it. */
-interface PoolPickCandidateView {
-    readonly identity: string;
-    readonly class: Candidate["class"];
-    readonly score?: number;
-    readonly feasible: boolean;
-    readonly blockedUntil?: string;
-    readonly plan: Candidate["plan"];
-    readonly reasons: readonly string[];
-}
-
 /**
  * Forward-only encoding of a real working directory into the single directory name Claude Code gives it under `~/.claude/projects/`.
  *
@@ -2850,8 +3046,11 @@ interface CredentialReport {
         readonly name: string;
         readonly credential?: CredentialSummary;
         readonly problem?: string;
+        readonly cached?: CachedCredentialState;
     };
     readonly identity?: CredentialSummary;
+    /** What the identity's own credential cache holds, when its block caches and the cache could be read. */
+    readonly identityCached?: CachedCredentialState;
 }
 /** Inputs to `runCheck` — everything already loaded/injected, exactly like the resolver core and the launcher: nothing in this function touches a real filesystem, git repository, clock, or environment itself. */
 interface RunCheckParams {
@@ -2887,6 +3086,8 @@ interface RunCheckParams {
     readonly platform: string;
     /** The provider a launch here would route through (`launch.provider` in the cascade), when one is selected. */
     readonly provider?: CheckProviderInput;
+    /** Where cached credentials live. Omit to skip reporting a credential cache's age; 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;
 }
 /** Everything `agent-shim check` reports about one directory/identity, without touching the farm or spawning anything. */
 interface CheckReport {
@@ -3021,6 +3222,8 @@ interface DoctorPathResolution {
 /** Everything `runDoctor` needs, all of it already loaded/injected — nothing in `runDoctor` itself reads a file, shells out, or touches the farm. */
 interface RunDoctorParams {
     readonly env: Readonly<Record<string, string | undefined>>;
+    /** 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;
     readonly identities: readonly DoctorIdentityInput[];
     readonly configProfiles: readonly DoctorConfigProfileInput[];
     readonly providers: readonly DoctorProviderInput[];
@@ -3184,5 +3387,5 @@ interface PrepareClaudeLaunchOptions {
  */
 declare function prepareClaudeLaunch(options: PrepareClaudeLaunchOptions): LaunchPlan;
 
-export { AMBIENT_CREDENTIAL_VARS, CONNECT_INTERCEPT_HOST, CONNECT_INTERCEPT_HOSTS, CONNECT_LIMITS, CONTROL_PATH_PREFIX, CategoryClassificationOverlaySchema, CategoryClassificationSchema, CategoryMapSchema, CliError, ConfigProfileSchema, CredentialCacheSchema, CredentialSchema, CredentialSourceSchema, DirectoryRuleAlreadyExistsError, DirectoryRuleMissingTargetError, DirectoryRuleNotFoundError, DirectoryRuleSchema, DirectoryRulesSchema, EXIT_FAILURE, EXIT_USAGE, EntryValueSchema, FARM_MANIFEST_FILENAME, FrontDoorStartError, GlobalConfigSchema, HeadroomStartError, IdentityAlreadyExistsError, IdentityNotFoundError, IdentitySchema, InvalidCategoryNameError, InvalidIdentityNameError, InvalidProviderNameError, LaunchRefusedError, LegacyProviderFileError, PoolNameSchema, PoolNotFoundError, PoolSchema, PortableConfigSchema, ProfileAlreadyExistsError, ProfileNotFoundError, ProviderAlreadyExistsError, ProviderKindMismatchError, ProviderNotFoundError, ProviderSchema, RC_IDLE_EXPIRY_MS, RC_PENDING_DEADLINE_MS, RC_PERMISSION_MODES, RC_REQUEST_PARSE_CAP_BYTES, RC_SESSIONS_PATH_PREFIX, ROUTED_PATH_PREFIX, UsageError, UsageSnapshotError, UsageSnapshotSchema, WhenSchema, addDirectoryRule, addIdentity, addPool, addProvider, answerRcControlRequest, buildEntryFacts, buildLayoutPaths, buildRcControlResponsePayload, buildRcEventWriteBody, buildRcInterruptPayload, buildRcSetModelPayload, buildRcSetPermissionModePayload, buildRcUserMessagePayload, carryOver, checkReportHasWarnings, checkReportToJson, collectCheckReport, collectDoctorReport, createLeafCache, createProfile, createRcControlHandler, createRcSessionTracker, describeProviderEndpoint, detectAmbientCredential, ensureCa, ensureFrontDoor, ensureHeadroom, evaluateAmbientCredentialGuard, formatAmbientCredentialGuardMessage, formatCheckReport, formatDoctorReport, forwardableHeaders, frontDoorRcControl, generateCa, identityExists, injectRcUserMessage, interruptRcSession, isIdentityDirectoryName, isInterceptedHost, isRcPermissionMode, listDirectoryRules, listIdentities, listProfiles, listProviders, listUsageSnapshots, mintLeaf, observingRoutedRoute, parseConnectTarget, prepareClaudeLaunch, prepareLaunch, profileExists, providerExists, rcEventWriteResultFromAnswer, rcObserverAsPassthrough, readActiveIdentity, readDirectoryRules, readFarmManifest, readGlobalConfig, readIdentity, readPools, readProfile, readProvider, readUsageSnapshot, realConnectCertStore, realConnectEffects, realRcControlTransport, realRcEventDial, recoverFarm, recoveryDiagnostics, removeDirectoryRule, removeIdentity, removePool, removeProfile, removeProvider, requirePool, resolveAgentShimHome, resolveClaudeHome, resolveDecisions, resolveLayoutPaths, resolveSupervisorConfig, resyncFarm, runCheck, runDoctor, runFrontDoorSupervisor, runSupervisor, servedByPipeline, setAllowAmbientCredential, setDefaultConfigProfile, setGlobalDefaultProfile, setIdentityCredential, setPool, setProfileCategories, setProfileEntries, setProfileLaunchFlags, setProfileMetadata, setRcSessionModel, setRcSessionPermissionMode, snapshotPath, startConnectServer, topLevelNames, updateDirectoryRule, updateProvider, useIdentity, writeDirectoryRules };
-export type { AddDirectoryRuleOptions, AddProviderInput, AmbientCredentialDetection, AmbientCredentialGuardResult, AmbientCredentialVar, BuildEntryFactsParams, CaMaterial, CarryOverParams, CarryOverResult, CategoryMap, CheckReport, CollectCheckReportParams, CollectDoctorReportParams, CompiledRule, ConfigProfile, ConnectCertStore, ConnectEffects, ConnectLimits, ConnectServerConfig, ConnectServerHandle, ConnectTarget, Credential, CredentialSource, Decision, Diagnostic, DirectoryRule, DirectoryRules, DoctorReport, EliminatedRule, EnsureFrontDoorPorts, EnsureHeadroomPorts, EntryFact, EntryFacts, EntryValue, EvaluateAmbientCredentialGuardParams, FlattenedCascade, FrontDoorRcControl, FrontDoorSupervisorPorts, GlobalConfig, HeadroomSupervisorConfig, Identity, IdentityCredentialChange, IdentityListEntry, IdentityListing, InjectedCredential, LaunchPlan, Layer, LayerId, LayoutPaths, LeafCert, Pool, PortableConfig, PrepareClaudeLaunchOptions, PrepareLaunchParams, ProfileListEntry, Provider, ProviderListEntry, RcAnswerDecision, RcAnswerDeps, RcControlAnswer, RcControlHandlerDeps, RcControlRequestDeps, RcControlTransport, RcDialAnswer, RcDialTarget, RcEventDial, RcEventWriteResult, RcExchangeObserver, RcInjectDeps, RcObservedCredential, RcObservedRequest, RcPendingRequestSummary, RcPermissionMode, RcSessionStatus, RcSessionSummary, RcSessionTracker, RcSessionTrackerDeps, RcWorkerFact, RcWriteHeaders, RecoverFarmParams, RecoveryResult, ResolveDecisionsInput, ResolvedState, ResyncFarmParams, ResyncFarmResult, RunCheckParams, RunDoctorParams, RunFrontDoorSupervisorOptions, RunSupervisorOptions, SupervisorPorts, UnreadableIdentityListEntry, UpdateDirectoryRuleOptions, UpdateProviderInput, UsageReadFs, UsageSnapshot, WhenCondition };
+export { AMBIENT_CREDENTIAL_VARS, CONNECT_INTERCEPT_HOST, CONNECT_INTERCEPT_HOSTS, CONNECT_LIMITS, CONTROL_PATH_PREFIX, CategoryClassificationOverlaySchema, CategoryClassificationSchema, CategoryMapSchema, CliError, ConfigProfileSchema, CredentialCacheSchema, CredentialSchema, CredentialSourceSchema, DirectoryRuleAlreadyExistsError, DirectoryRuleMissingTargetError, DirectoryRuleNotFoundError, DirectoryRuleSchema, DirectoryRulesSchema, EXIT_FAILURE, EXIT_USAGE, EntryValueSchema, FARM_MANIFEST_FILENAME, FrontDoorStartError, GlobalConfigSchema, 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_PENDING_DEADLINE_MS, RC_PERMISSION_MODES, RC_REQUEST_PARSE_CAP_BYTES, RC_SESSIONS_PATH_PREFIX, ROUTED_PATH_PREFIX, UsageError, UsageSnapshotError, UsageSnapshotSchema, WhenSchema, addDirectoryRule, addIdentity, addPool, addProvider, answerRcControlRequest, buildEntryFacts, buildLayoutPaths, buildRcControlResponsePayload, buildRcEventWriteBody, buildRcInterruptPayload, buildRcSetModelPayload, buildRcSetPermissionModePayload, buildRcUserMessagePayload, carryOver, checkReportHasWarnings, checkReportToJson, collectCheckReport, collectDoctorReport, collectPoolPick, createLeafCache, createProfile, createRcControlHandler, createRcSessionTracker, describeProviderEndpoint, detectAmbientCredential, effectiveWindow, ensureCa, ensureFrontDoor, ensureHeadroom, evaluateAmbientCredentialGuard, evaluateWhen, formatAmbientCredentialGuardMessage, formatCheckReport, formatDoctorReport, forwardableHeaders, frontDoorRcControl, generateCa, identityExists, injectRcUserMessage, interruptRcSession, isIdentityDirectoryName, isInterceptedHost, isRcPermissionMode, listDirectoryRules, listIdentities, listProfiles, listProviders, listUsageSnapshots, matchBranch, mintLeaf, observingRoutedRoute, parseConnectTarget, planOf, prepareClaudeLaunch, prepareLaunch, profileExists, providerExists, rankPool, rcEventWriteResultFromAnswer, rcObserverAsPassthrough, readActiveIdentity, readDirectoryRules, readFarmManifest, readGlobalConfig, readIdentity, readPools, readProfile, readProvider, readUsageSnapshot, realConnectCertStore, realConnectEffects, realRcControlTransport, realRcEventDial, recoverFarm, recoveryDiagnostics, removeDirectoryRule, removeIdentity, removePool, removeProfile, removeProvider, requirePool, resolveAgentShimHome, resolveClaudeHome, resolveDecisions, resolveLayoutPaths, resolveSupervisorConfig, resyncFarm, runCheck, runDoctor, runFrontDoorSupervisor, runSupervisor, servedByPipeline, setAllowAmbientCredential, setDefaultConfigProfile, setGlobalDefaultProfile, setIdentityCredential, setPool, setProfileCategories, setProfileEntries, setProfileLaunchFlags, setProfileMetadata, setRcSessionModel, setRcSessionPermissionMode, snapshotPath, startConnectServer, topLevelNames, updateDirectoryRule, updateProvider, useIdentity, writeDirectoryRules };
+export type { AddDirectoryRuleOptions, AddProviderInput, AmbientCredentialDetection, AmbientCredentialGuardResult, AmbientCredentialVar, BuildEntryFactsParams, CaMaterial, Candidate, CarryOverParams, CarryOverResult, CategoryMap, CheckReport, CollectCheckReportParams, CollectDoctorReportParams, CompiledRule, ConditionContext, ConfigProfile, ConnectCertStore, ConnectEffects, ConnectLimits, ConnectServerConfig, ConnectServerHandle, ConnectTarget, Credential, CredentialSource, Decision, Diagnostic, DirectoryRule, DirectoryRules, DoctorReport, EffectiveWindow, EliminatedRule, EnsureFrontDoorPorts, EnsureHeadroomPorts, EntryFact, EntryFacts, EntryValue, EvaluateAmbientCredentialGuardParams, FlattenedCascade, FrontDoorRcControl, 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, RcControlAnswer, RcControlHandlerDeps, RcControlRequestDeps, RcControlTransport, RcDialAnswer, RcDialTarget, RcEventDial, RcEventWriteResult, RcExchangeObserver, RcInjectDeps, RcObservedCredential, RcObservedRequest, RcPendingRequestSummary, RcPermissionMode, RcSessionStatus, RcSessionSummary, RcSessionTracker, RcSessionTrackerDeps, RcWorkerFact, RcWriteHeaders, RecoverFarmParams, RecoveryResult, ResolveDecisionsInput, ResolvedState, ResyncFarmParams, ResyncFarmResult, RunCheckParams, RunDoctorParams, RunFrontDoorSupervisorOptions, RunSupervisorOptions, StickyPick, SupervisorPorts, UnreadableIdentityListEntry, UpdateDirectoryRuleOptions, UpdateProviderInput, UsageReadFs, UsageSnapshot, WhenCondition, WhenEvaluation };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agent-shim",
-  "version": "8.6.0",
+  "version": "8.8.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>",