agent-shim 11.85.0 → 11.86.0

package/dist/types/index.d.ts

@@ -5505,7 +5505,7 @@ type CategoryClassificationOverlay = z.infer<typeof CategoryClassificationOverla
 interface LayoutPaths {
     /** The resolved root directory, see `resolveAgentShimHome`. */
     readonly root: string;
-    /** Directory holding one subdirectory per identity (symlink farm + local credentials/daemon state). */
+    /** Directory holding one subdirectory per identity (symlink farm + local credentials/daemon state), named by the identity's id: the name it was created with, or a free variant of it, kept for good by a rename, which changes only the `name` in its `identity.json`. */
     readonly identitiesDir: string;
     /** Directory holding named, reusable configuration profile JSON files. */
     readonly configProfilesDir: string;
@@ -5579,7 +5579,7 @@ interface LayoutPaths {
     readonly usageDir: string;
     /** Directory of the append-only usage log: one `<YYYY-MM-DD>.<writer-pid>.jsonl` segment per writing process per UTC day. */
     readonly usageLogDir: string;
-    /** Directory of the latest-state snapshots, one `<identity>.json` per identity: the stable file other tools read. */
+    /** Directory of the latest-state snapshots, one `<id>.json` per identity, named by the id the identity is stored under (its directory's name, which a rename keeps), never by its name: the stable file other tools read. */
     readonly usageSnapshotsDir: string;
     /** Directory of the built-in statusline's own state (the day's cost ledger, under `session/` what it keeps between refreshes about each transcript it reads, and under `run/` the short-lived output files of the programs it runs), each file of the ledger and under `session/` read as absent when it is missing, is not a regular file or is not of its shape, and none restored: a session's entry for today in the cost ledger starts again from the cost reported by the session's next render that lists the `dailyCost` segment and has a cost to record (or from the previous day's total, by the rule a session's first render of the day carries it by), so the day's total no longer counts what the session spent before that figure, and its entry for the day before, which is only read, carries nothing; the transcript reader's cache is folded again from the start of the transcript; the speed sample is replaced by that of the next render that lists the `speed` segment and has a figure to measure, which draws no speed; and the transcript's last good context frame is none until the next good frame is written. */
     readonly statuslineDir: string;
@@ -5597,7 +5597,9 @@ interface LayoutPaths {
     readonly jobLogsDir: string;
     /** Directory holding one journal per unfinished `identity rename`, written before its first step and removed when it ends: the trace a rename that was killed leaves, which a re-run resumes from and `doctor` reports. Runtime state, never configuration. */
     readonly identityRenamesDir: string;
-    /** Directory holding one `<launcher-pid>.<identity>.json` record per launch in progress, written before the identity's farm is resynced and removed once the child has exited. Runtime state, never configuration: it is what lets an identity rename see a launch that has resynced but not yet started its child. */
+    /** Directory holding one record per rename of the name alone that is applying, written before its first rewrite and removed when it ends or is rolled back: what tells a rename killed part way, whose references already name the new name, from references a person wrote. Runtime state, never configuration. */
+    readonly identityNameRenamesDir: string;
+    /** Directory holding one `<launcher-pid>.<id>.json` record per launch in progress, named by the id of the identity it launches, written before the identity's farm is resynced and removed once the child has exited. Runtime state, never configuration: it is what lets `identity rename --move` see a launch that has resynced but not yet started its child. */
     readonly launchesDir: string;
     /** Directory of the supervised sessions' shared state, one subdirectory per pool: the live sessions each launcher registers, so sessions on one account see each other, and the lock that serialises their moves. Runtime state, never configuration. */
     readonly superviseDir: string;
@@ -6319,7 +6321,7 @@ interface ResyncFarmParams {
     /** Distinguishes this resync's scratch and superseded directory names from any other process's. `${pid}.${uuid}` in real use; a fixed string in tests. */
     readonly uniqueSuffix: string;
     /**
-     * Whether the identity still exists, asked once the lock is held and any interrupted swap recovered. A launch that waited for the lock while the identity was renamed or removed must not rebuild its directory, so a caller that can answer passes it and `resyncFarm` throws `IdentityGoneError` on `false`. Absent means the caller has no way to tell.
+     * Whether the identity still exists, asked once the lock is held and any interrupted swap recovered. A launch that waited for the lock while the identity's directory was moved with `identity rename --move` or removed must not rebuild it (a rename of the name alone leaves the directory where it was), so a caller that can answer passes it and `resyncFarm` throws `IdentityGoneError` on `false`. Absent means the caller has no way to tell.
      */
     readonly identityExists?: () => boolean;
     readonly lock: {
@@ -8478,7 +8480,7 @@ declare const CheckReportJsonSchema: z.ZodObject<{
 }, z.core.$strict>;
 type CheckReportJson = z.output<typeof CheckReportJsonSchema>;
 
-/** What a cache stores for one credential: the token, when it was fetched, and the source that produced it (a non-secret descriptor, kept so `check` and the launch log can still say where the token came from). */
+/** What a cache stores for one credential: the token, when it was fetched, the source that produced it (a non-secret descriptor, kept so `check` and the launch log can still say where the token came from), and, in the file store, the owner it was cached for (`identity <id>`, `provider <name>`), which the file store records on every write; the Keychain store files each entry under its owner's account and records none. A file-store entry with no `owner` was written before owners were recorded. */
 declare const CachedCredentialSchema: z.ZodObject<{
     token: z.ZodString;
     fetchedAt: z.ZodNumber;
@@ -8504,6 +8506,7 @@ declare const CachedCredentialSchema: z.ZodObject<{
     }, z.core.$strict>, z.ZodObject<{
         literal: z.ZodString;
     }, z.core.$strict>]>;
+    owner: z.ZodOptional<z.ZodString>;
 }, z.core.$strict>;
 type CachedCredential = z.infer<typeof CachedCredentialSchema>;
 /**
@@ -8811,6 +8814,8 @@ interface RunCheckParams {
         readonly overlay?: CategoryClassificationOverlay;
     };
     readonly identityName?: string;
+    /** The id the resolved identity is stored under, which keys its cached credential (see `identityCacheKey`). */
+    readonly identityId?: string;
     readonly identitySource: IdentityDecisionSource;
     /** The pool the launch selected and how it ranks right now, when it named a pool instead of an identity; `identityName` is then the member it would pick. */
     readonly poolPick?: PoolPickReport;
@@ -8906,94 +8911,6 @@ type PathShadowStatus = {
     readonly by: string;
 };
 
-/** Raised by any operation that requires an identity to already exist, when it does not. */
-declare class IdentityNotFoundError extends CliError {
-    readonly name: string;
-    constructor(name: string);
-}
-/** Raised by `addIdentity` when an identity with the given name already has an `identity.json`. */
-declare class IdentityAlreadyExistsError extends CliError {
-    readonly identityName: string;
-    constructor(identityName: string);
-}
-/** Raised by `addIdentity` when `name` fails `IdentitySchema`'s own naming rule — it must start with a letter or number and may then contain letters, numbers, dots, hyphens, underscores, and at signs, so an email address names an identity directly while a *leading* `@` stays invalid (it would collide with the `@name` selector syntax's first-`@` split). */
-declare class InvalidIdentityNameError extends CliError {
-    readonly attemptedName: string;
-    constructor(attemptedName: string);
-}
-declare function identityExists(paths: LayoutPaths, name: string): boolean;
-/** Reads and validates one identity's `identity.json`, or undefined when it does not exist. */
-declare function readIdentity(paths: LayoutPaths, name: string): Identity | undefined;
-/**
- * Creates a new identity: validates `name` against `IdentitySchema`'s own naming rule and writes a fresh `identity.json` with `allowAmbientCredential: false` and no `defaultConfigProfile`.
- *
- * Throws a `CliError` naming the command that finishes the rename when an unfinished rename names `name` (see `requireNoUnfinishedRenameNaming`), `IdentityAlreadyExistsError` if an identity with this name already has an `identity.json`, since `add` never silently overwrites an existing identity. Throws `InvalidIdentityNameError` when `name` fails `IdentitySchema`'s naming rule, rather than letting the underlying `ZodError` escape as an unhandled crash.
- */
-declare function addIdentity(paths: LayoutPaths, name: string): Identity;
-/**
- * Persists `name` as the active identity, written atomically as plain text (not JSON — this file is read by `decideIdentity` in `src/launcher/identity.ts` via a simple UTF-8 read-and-trim, matching the README's documented `~/.agent-shim/active-identity` file).
- *
- * `name` may be a `pool:<name>` selector, which makes launches pick a member of that pool. Throws `IdentityNotFoundError` when no identity with this name exists yet, and `PoolNotFoundError` for a pool that is not defined: selecting either would silently persist a name nothing else can ever load.
- */
-declare function useIdentity(paths: LayoutPaths, name: string): void;
-/** Reads the persisted active-identity file, or undefined when none is set. */
-declare function readActiveIdentity(paths: LayoutPaths): string | undefined;
-/**
- * Whether a directory name directly under `identitiesDir` names an actual identity, rather than one of agent-shim's own farm directories.
- *
- * `IdentitySchema` requires an identity name to start with a letter or digit, so a leading `.` can only be a resync's own bookkeeping: a `.<identity>.scratch.<suffix>` tree still being built, or a `.<identity>.previous.<suffix>` superseded farm retained for `agent-shim identity resolve-conflicts`. Neither is an identity, and neither should be reported as a broken one for lacking an `identity.json` a resync never put there.
- */
-declare function isIdentityDirectoryName(name: string): boolean;
-/** An entry directly under `identitiesDir` that cannot be reached, and why: `code` is the error the filesystem gave. */
-interface UnreachableIdentityEntry {
-    readonly name: string;
-    readonly code: string;
-}
-/** One identity as reported by `listIdentities`, whose `identity.json` parsed and validated cleanly. */
-interface IdentityListEntry {
-    readonly name: string;
-    readonly identity: Identity;
-    readonly isActive: boolean;
-    readonly problem?: never;
-}
-/** One identity whose `identity.json` is present but unreadable — malformed JSON, or valid JSON this version's `IdentitySchema` rejects. `problem` carries the reason, already flattened onto a single line. */
-interface UnreadableIdentityListEntry {
-    readonly name: string;
-    readonly identity?: never;
-    readonly isActive: boolean;
-    readonly problem: string;
-}
-/** Either shape `listIdentities` can report, discriminated by which of `identity`/`problem` is present rather than by a tag field — the two are never simultaneously satisfiable. */
-type IdentityListing = IdentityListEntry | UnreadableIdentityListEntry;
-/**
- * Lists every identity under `identitiesDir`, marking which one (if any) is currently active.
- *
- * One identity whose `identity.json` cannot be read is reported as its own `UnreadableIdentityListEntry` rather than aborting the whole listing. A single bad file blocking `identity list` outright is exactly the failure mode that hides every *other* identity from view at the moment the user most needs to see them — and the file need not even be corrupt to land here, since a name written by a newer agent-shim whose naming rule has since widened is rejected outright by an older binary's own copy of `IdentitySchema`.
- */
-declare function listIdentities(paths: LayoutPaths): readonly IdentityListing[];
-/**
- * Sets `identity`'s `defaultConfigProfile` field, or clears it when `profileName` is undefined. Throws `IdentityNotFoundError` when the identity does not exist. Whether the profile exists is the caller's concern: `identity set --default-profile` checks it first.
- */
-declare function setDefaultConfigProfile(paths: LayoutPaths, identityName: string, profileName: string | undefined): Identity;
-/**
- * Patches `identity`'s `allowAmbientCredential` field. Throws `IdentityNotFoundError` when the identity does not exist.
- */
-declare function setAllowAmbientCredential(paths: LayoutPaths, identityName: string, allow: boolean): Identity;
-/** The change `setIdentityCredential` makes: new sources and/or a new target for the credential block, or `false` to remove the block and return the identity to its stored login. */
-type IdentityCredentialChange = {
-    readonly sources?: readonly CredentialSource[];
-    readonly target?: CredentialTarget;
-    readonly cache?: CredentialCache | false;
-} | false;
-/**
- * Sets, changes or removes `identityName`'s credential block. New `sources` replace the whole ordered list (the order is the meaning); a `target` alone keeps the existing sources, and so needs a credential block to exist already. Throws `IdentityNotFoundError` when the identity does not exist, and `UsageError` when only a target is given for an identity with no credential yet.
- */
-declare function setIdentityCredential(paths: LayoutPaths, identityName: string, change: IdentityCredentialChange): Identity;
-/**
- * Deletes identity `name` entirely: its directory under `identitiesDir` (the farm, its `identity.json`, and whatever that farm holds unshared, credentials included), its resync lock, any scratch or superseded farm a resync left behind, and the active-identity selection when it names this identity. Data shared into `~/.claude` stays there, since the farm only ever symlinks to it. Throws a `CliError` naming the command that finishes the rename when an unfinished rename names `name`, and `IdentityNotFoundError` when the identity does not exist.
- */
-declare function removeIdentity(paths: LayoutPaths, name: string): void;
-
 /** One routed request, appended to the usage log when its response has finished. */
 declare const UsageRecordSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
@@ -9067,7 +8984,7 @@ declare const AccountMetadataSchema: z.ZodObject<{
 }, 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`.
+ * The latest state for one identity, rewritten atomically after each recorded response: the snapshot file other tools read (`~/.agent-shim/usage/snapshots/<id>.json`, named and keyed in `identity` by the identity's id) without shelling out to `agent-shim`.
  */
 declare const UsageSnapshotSchema: z.ZodObject<{
     schemaVersion: z.ZodLiteral<1>;
@@ -9168,6 +9085,193 @@ declare const UsageSnapshotSchema: z.ZodObject<{
 }, z.core.$strict>;
 type UsageSnapshot = z.infer<typeof UsageSnapshotSchema>;
 
+/**
+ * The read side of the usage store: pure over an injected filesystem, so the CLI, the library surface and tests all read the same way, and nothing here writes.
+ */
+/** The filesystem reads the usage store's readers need. */
+type UsageReadFs = Pick<FarmFs, "readFileUtf8" | "readdir">;
+/** Raised for a snapshot file that exists but does not hold a snapshot of this schema version. */
+declare class UsageSnapshotError extends Error {
+    readonly file: string;
+    constructor(file: string, detail: string);
+}
+/** The path of the snapshot filed under identity id `identity` (`<snapshotsDir>/<id>.json`). Throws for an id that is not a valid identity directory id, since such an id could name a path outside the snapshots directory. */
+declare function snapshotPath(snapshotsDir: string, identity: string): string;
+/** Reads the snapshot filed under identity id `identity`: undefined when there is none yet, `UsageSnapshotError` when the file is there but unreadable. */
+declare function readUsageSnapshot(fs: Pick<FarmFs, "readFileUtf8">, snapshotsDir: string, identity: string): UsageSnapshot | undefined;
+/** Reads every snapshot in the directory, each filed under the id of the identity it belongs to (its `identity` field is that id). */
+declare function listUsageSnapshots(fs: UsageReadFs, snapshotsDir: string): readonly UsageSnapshot[];
+
+/** Everything `acquireIdentityLock` needs, all of it injected so a test never sleeps for real, never reads a real pid table, and never writes outside its own fake filesystem. */
+interface AcquireIdentityLockParams {
+    readonly identity: string;
+    /** The directory the lock file lives in — `~/.agent-shim/identities`, alongside (never inside) the farm the lock protects, so a farm swap can rename the farm root out from under itself without disturbing the lock. */
+    readonly dir: string;
+    readonly fs: FarmFs;
+    readonly nowMs: () => number;
+    readonly pid: number;
+    /** Answers whether a process is still running, so a lock left behind by a crash is recognised rather than waited out for the full staleness window. Zombie-aware: a holder that exited without being reaped still answers signal 0 as alive, but will never release the lock itself. */
+    readonly isRunning: (pid: number) => boolean;
+    /** Blocks for the given number of milliseconds. Synchronous by necessity: the whole launcher is synchronous, right through to `spawnSync`. */
+    readonly sleep: (ms: number) => void;
+    readonly staleAfterMs?: number;
+    readonly retryDelayMs?: number;
+    readonly maxAttempts?: number;
+}
+
+/** What taking the identity names lock needs from the machine: the lock's own ports, and how many attempts to make before giving up (one for a caller that must not wait, such as the front door, whose event loop a sleep would hold). */
+type IdentityNamesLockPorts = Pick<AcquireIdentityLockParams, "fs" | "nowMs" | "pid" | "isRunning" | "sleep" | "maxAttempts">;
+
+/**
+ * One identity as its storage knows it. `id` is the name of its directory under the identities directory: it is chosen when the identity is created and never changes, so everything filed under it (the directory, the `CLAUDE_CONFIG_DIR` every session holds, the macOS Keychain login filed under a hash of that path, the resync lock, the usage snapshot) stays valid across a rename. `name` is what `identity.json` calls the identity: every command, selector and configuration reference uses it, and `identity rename` changes it alone.
+ */
+interface IdentityRecord {
+    readonly id: string;
+    /** Undefined when the record's `identity.json` gives no name that can be read: such a record claims no name, so it can never collide with one another identity holds. */
+    readonly name: string | undefined;
+}
+/** What reading one `identity.json` for its name found: the name, no file there, or a file whose name cannot be read (not JSON, or no string `name`). */
+type IdentityNameRead = {
+    readonly name: string;
+} | "absent" | "unreadable";
+/** What reading the records needs: the entries directly under the identities directory, and the name in one `identity.json`. Injected so the launcher's configuration port, the farm's filesystem port and the real filesystem all resolve through the same rule. */
+interface IdentityRecordsPort {
+    readonly readdir: (directory: string) => readonly string[];
+    readonly readName: (identityJson: string) => IdentityNameRead;
+    /** Whether two entries are one directory on disk, which a symlink beside an identity's directory makes them. */
+    readonly sameDirectory: (first: string, second: string) => boolean;
+    /** Whether an entry is itself a symlink, read without following it: of two entries that are one directory, the one that is not is the identity's own. */
+    readonly isSymlink: (entry: string) => boolean;
+}
+/**
+ * Every identity record under `identitiesDir`, sorted by id. An entry whose name does not start with a dot is an identity when it holds an `identity.json`: the record takes the name that file gives, or no name when the file's name cannot be read (see `identityIdIn` for how such a record is still reached). An entry with no `identity.json` is not an identity unless a superseded farm of it holds one (below).
+ *
+ * Two entries that are one directory on disk, as a symlink beside an identity's directory makes them, are one record: the entry that is the directory itself rather than a symlink to it, or else the first by id. The choice reads the filesystem, never the name, so a rename of the name never changes which entry is the identity's id.
+ *
+ * A superseded farm (`.<id>.previous.<suffix>`) whose identity's entry holds no `identity.json` (no directory at all, a resync killed between the two renames of its swap; or the new farm swapped in before the file was carried over into it) is the trace the launcher's recovery repairs: until then the identity's `identity.json` is inside it, so the record is read from there (from the first such farm in name order that holds an `identity.json`, which is the farm the launcher's recovery restores; a farm retained from an earlier swap for its conflicts holds none, since a completed swap carries the file over), and the identity can still be found by name to be recovered.
+ */
+declare function readIdentityRecords(port: IdentityRecordsPort, identitiesDir: string): readonly IdentityRecord[];
+/** Raised when two identity records claim one name: nothing can tell which of them a reference to the name means, so nothing resolves it until one is renamed. `doctor` reports the same. */
+declare class DuplicateIdentityNameError extends CliError {
+    readonly identityName: string;
+    readonly ids: readonly string[];
+    constructor(identityName: string, ids: readonly string[]);
+}
+
+/** Raised by any operation that requires an identity to already exist, when it does not. `remedy` says what to do, adding the identity unless given (`identityNotFound` gives it from the state on disk). */
+declare class IdentityNotFoundError extends CliError {
+    readonly name: string;
+    constructor(name: string, remedy?: string);
+}
+/** Raised when an identity already claims the given name: by `addIdentity`, and by a rename to that name. */
+declare class IdentityAlreadyExistsError extends CliError {
+    readonly identityName: string;
+    constructor(identityName: string);
+}
+/** Raised by `addIdentity` when `name` fails `IdentitySchema`'s own naming rule — it must start with a letter or number and may then contain letters, numbers, dots, hyphens, underscores, and at signs, so an email address names an identity directly while a *leading* `@` stays invalid (it would collide with the `@name` selector syntax's first-`@` split). */
+declare class InvalidIdentityNameError extends CliError {
+    readonly attemptedName: string;
+    constructor(attemptedName: string);
+}
+/** Every identity's record (its id, the directory it is stored in, and its name), read fresh from the identities directory. See `readIdentityRecords`. */
+declare function identityRecords(paths: LayoutPaths): readonly IdentityRecord[];
+/** The id (the directory under `identitiesDir`) of the identity named `name`, or undefined when there is none. Every lookup of an identity by name goes through this, since a renamed identity keeps the directory it was created with. Throws `DuplicateIdentityNameError` when two identities claim the name. */
+declare function identityIdOf(paths: LayoutPaths, name: string): string | undefined;
+/** The name of the identity stored under id `id`, or undefined when no identity is. */
+declare function identityNameOf(paths: LayoutPaths, id: string): string | undefined;
+/** Whether an identity is named `name`. Throws `DuplicateIdentityNameError` when two are. */
+declare function identityExists(paths: LayoutPaths, name: string): boolean;
+/** Reads and validates the `identity.json` of the identity named `name`, or undefined when there is none. */
+declare function readIdentity(paths: LayoutPaths, name: string): Identity | undefined;
+/** Reads and validates the `identity.json` stored under id `id`, or undefined when there is none. */
+declare function readIdentityById(paths: LayoutPaths, id: string): Identity | undefined;
+/** How `addIdentity` reaches what it needs beyond the files: the identity names lock, and, for an add whose id was checked before the lock was taken (`requireIdentityAddable`), that id. */
+interface AddIdentityOptions {
+    readonly namesLock?: IdentityNamesLockPorts;
+    readonly checkedId?: string;
+}
+/**
+ * Creates a new identity: validates `name` against `IdentitySchema`'s own naming rule and writes a fresh `identity.json` with `allowAmbientCredential: false` and no `defaultConfigProfile`, in the directory `newIdentityId` gives (the name itself unless something is already filed under it), or in `options.checkedId` when the add was checked against that id, which is used only while it is still free.
+ *
+ * Every check is made, and the file written, holding the identity names lock (`options.namesLock` reaches it; see `acquireIdentityNamesLock`), so a rename or another add cannot give the name to a second identity in between. Throws `IdentityLockBusyError` when the lock stays held, a `CliError` naming the command that finishes the rename when an unfinished rename names `name` or its id (see `requireNoUnfinishedRenameNaming`), `IdentityAlreadyExistsError` if an identity is already named `name`, since `add` never silently overwrites an existing identity, and a `CliError` when the checked id was taken in between. Throws `InvalidIdentityNameError` when `name` fails `IdentitySchema`'s naming rule, rather than letting the underlying `ZodError` escape as an unhandled crash.
+ *
+ * It does not ask the Keychain: called alone, it neither passes over an id whose cached credential the Keychain store still holds nor refuses over a Claude Code login left for the directory. `identity add` and the door make those checks first (`requireIdentityAddable`, then this with `checkedId`, as `addNewIdentity` does).
+ */
+declare function addIdentity(paths: LayoutPaths, name: string, options?: AddIdentityOptions): Identity;
+/**
+ * Persists `name` as the active identity, written atomically as plain text (not JSON — this file is read by `decideIdentity` in `src/launcher/identity.ts` via a simple UTF-8 read-and-trim, matching the README's documented `~/.agent-shim/active-identity` file).
+ *
+ * `name` may be a `pool:<name>` selector, which makes launches pick a member of that pool. Throws `IdentityNotFoundError` when no identity with this name exists yet, and `PoolNotFoundError` for a pool that is not defined: selecting either would silently persist a name nothing else can ever load.
+ */
+declare function useIdentity(paths: LayoutPaths, name: string, namesLock?: IdentityNamesLockPorts): void;
+/** Reads the persisted active-identity file, or undefined when none is set. */
+declare function readActiveIdentity(paths: LayoutPaths): string | undefined;
+/**
+ * Whether a directory name directly under `identitiesDir` names an actual identity, rather than one of agent-shim's own farm directories.
+ *
+ * `IdentitySchema` requires an identity name to start with a letter or digit, so a leading `.` can only be a resync's own bookkeeping: a `.<identity>.scratch.<suffix>` tree still being built, or a `.<identity>.previous.<suffix>` superseded farm retained for `agent-shim identity resolve-conflicts`. Neither is an identity, and neither should be reported as a broken one for lacking an `identity.json` a resync never put there.
+ */
+declare function isIdentityDirectoryName(name: string): boolean;
+/** An entry directly under `identitiesDir` that cannot be reached, and why: `code` is the error the filesystem gave. */
+interface UnreachableIdentityEntry {
+    readonly name: string;
+    readonly code: string;
+}
+/** One identity as reported by `listIdentities`, whose `identity.json` parsed and validated cleanly. `name` is the name it gives; `id` is the directory it is stored under. */
+interface IdentityListEntry {
+    readonly name: string;
+    readonly id: string;
+    readonly identity: Identity;
+    readonly isActive: boolean;
+    readonly problem?: never;
+    readonly displaced?: never;
+}
+/** One identity whose `identity.json` cannot be read where it belongs: malformed, rejected by `IdentitySchema`, or (with `displaced`) left only in a superseded farm. `problem` carries the reason, already flattened onto a single line. `name` is the name the file gives when that much of it can be read, and otherwise its id (the record of such a file claims no name). */
+interface UnreadableIdentityListEntry {
+    readonly name: string;
+    readonly id: string;
+    readonly identity?: never;
+    readonly isActive: boolean;
+    readonly problem: string;
+    /** Set when the file is not unreadable but displaced: an interrupted resync left it only in a superseded farm, and the next launch of the identity puts it back. */
+    readonly displaced?: true;
+}
+/** Either shape `listIdentities` can report, discriminated by which of `identity`/`problem` is present rather than by a tag field — the two are never simultaneously satisfiable. */
+type IdentityListing = IdentityListEntry | UnreadableIdentityListEntry;
+/**
+ * Lists every identity under `identitiesDir`, sorted by name, marking which one (if any) is currently active. Two identities that claim one name are both listed; `doctor` reports them.
+ *
+ * One identity whose `identity.json` cannot be read is reported as its own `UnreadableIdentityListEntry` rather than aborting the whole listing. A single bad file blocking `identity list` outright is exactly the failure mode that hides every *other* identity from view at the moment the user most needs to see them — and the file need not even be corrupt to land here, since a name written by a newer agent-shim whose naming rule has since widened is rejected outright by an older binary's own copy of `IdentitySchema`.
+ */
+declare function listIdentities(paths: LayoutPaths): readonly IdentityListing[];
+/**
+ * Sets `identity`'s `defaultConfigProfile` field, or clears it when `profileName` is undefined. Throws `IdentityNotFoundError` when the identity does not exist. Whether the profile exists is the caller's concern: `identity set --default-profile` checks it first.
+ */
+declare function setDefaultConfigProfile(paths: LayoutPaths, identityName: string, profileName: string | undefined): Identity;
+/**
+ * Patches `identity`'s `allowAmbientCredential` field. Throws `IdentityNotFoundError` when the identity does not exist.
+ */
+declare function setAllowAmbientCredential(paths: LayoutPaths, identityName: string, allow: boolean): Identity;
+/** The change `setIdentityCredential` makes: new sources and/or a new target for the credential block, or `false` to remove the block and return the identity to its stored login. */
+type IdentityCredentialChange = {
+    readonly sources?: readonly CredentialSource[];
+    readonly target?: CredentialTarget;
+    readonly cache?: CredentialCache | false;
+} | false;
+/**
+ * Sets, changes or removes `identityName`'s credential block. New `sources` replace the whole ordered list (the order is the meaning); a `target` alone keeps the existing sources, and so needs a credential block to exist already. Throws `IdentityNotFoundError` when the identity does not exist, and `UsageError` when only a target is given for an identity with no credential yet.
+ */
+declare function setIdentityCredential(paths: LayoutPaths, identityName: string, change: IdentityCredentialChange): Identity;
+/**
+ * Deletes the identity named `name` entirely: its directory under `identitiesDir` (the farm, its `identity.json`, and whatever that farm holds unshared, credentials included; for an entry that is a symlink, the link and not what it points to), every other entry there that is the same directory (each symlink to it), its resync lock, any scratch or superseded farm a resync left behind, the files outside the directory that hold its state under its id (`REMOVED_STATE`: its stored token, its cached credential in the file store, which the store deletes only when it is this identity's own or was cached before owners were recorded, and its usage snapshot), and the active-identity selection when it names this identity. Returns the id it was stored under, so a caller that can reach the Keychain forgets a credential cached there too. Data shared into `~/.claude` stays there, since the farm only ever symlinks to it. Throws a `CliError` naming the command that finishes the rename when an unfinished rename names `name` or the identity's id, `IdentityNotFoundError` when no identity is named `name`, and `DuplicateIdentityNameError` when two are. It holds the identity names lock throughout, so it never removes an identity a rename is applying to, and throws `IdentityLockBusyError` when that stays held; it then takes the identity's own resync lock, so it never removes an identity a launch is resyncing, and throws `IdentityRemovalBusyError` (naming the launch to let finish or stop) when that is held.
+ */
+declare function removeIdentity(paths: LayoutPaths, name: string, namesLock?: IdentityNamesLockPorts): string;
+
+/** A record read from a superseded farm, with whether its identity's directory is present (holding no `identity.json` yet) or missing. */
+interface DisplacedIdentityRecord extends IdentityRecord {
+    readonly directoryPresent: boolean;
+}
+
 /**
  * How the allowlist the headroom daemon serves lags the allowlist computed now. The daemon re-reads its allowlist file on every request that follows a change to it, and its supervisor rewrites the file and records the hash in the same tick, so a lag that lasts beyond one tick means the supervisor is not running or cannot write the file. A daemon started by an earlier release reads no file, and is reported as such instead.
  */
@@ -9399,10 +9503,13 @@ interface DoctorReport {
 }
 /** One identity's raw `identity.json`, unparsed — `runDoctor` does its own JSON.parse/schema validation so one malformed file never aborts the rest of the report. */
 interface DoctorIdentityInput {
+    /** The name its `identity.json` gives it when that much of the file can be read, and otherwise its id (the record of such a file claims no name). */
     readonly name: string;
+    /** Its storage id: the directory under the identities directory it is stored in. */
+    readonly id: string;
     readonly path: string;
     readonly raw: string | undefined;
-    /** The identity's own farm root (`identitiesDir/<name>`) — the account name the Keychain lookup uses. */
+    /** The identity's own farm root (`identitiesDir/<id>`): the account name the Keychain lookup uses. */
     readonly farmRoot: string;
     /** Whether the identity's `.credentials.json` exists, pre-resolved by the wiring layer since it is a file-existence check. */
     readonly credentialsFilePresent: boolean;
@@ -9467,6 +9574,16 @@ interface RunDoctorParams {
     readonly renameJournals?: RenameJournalListing;
     /** The entries of the identities directory that cannot be reached (a symlink the filesystem would not follow, or a directory nobody can enter), which are not counted as identities. Omit to leave them out of the findings. */
     readonly unreachableIdentities?: readonly UnreachableIdentityEntry[];
+    /** Every identity's record as the resolver reads it (`all`, see `readIdentityRecords`), which a name two of them claim is found in, and those whose directory is missing, or present without `identity.json`, while a superseded farm a resync left holds their `identity.json` (`displaced`), which the next launch puts back, and the renames of the name alone left half done, each with the sentence that says what it rewrote and how it is finished (`unfinishedNameRenames`), and the files under `identity-name-renames/` holding a record that no rename filed there (`strayNameRenameFiles`, see `strayNameRenameRecordFiles`). Omit to leave them out of the findings. */
+    readonly identityRecords?: {
+        readonly all: readonly IdentityRecord[];
+        readonly displaced: readonly DisplacedIdentityRecord[];
+        readonly nameRenames?: readonly {
+            readonly from: string;
+            readonly description: string;
+        }[];
+        readonly strayNameRenameFiles?: readonly string[];
+    };
     readonly directoryRules: DoctorFileInput;
     readonly globalConfig: DoctorFileInput;
     /** The parsed `models` block of the global config, when one is defined. Omit to skip the models checks. */
@@ -9508,6 +9625,13 @@ interface RunDoctorParams {
         readonly listeners?: readonly FrontDoorListenerReading[];
     };
 }
+/**
+ * Audits the whole `~/.agent-shim` config graph for internal consistency: every identity, every configuration profile's own `extends` chain, every provider, `directory-rules.json`, `config.json`, `categories.local.json`, `active-identity`, plus real Claude Code binary discoverability and ambient-credential exposure.
+ *
+ * Deliberately identity/directory-agnostic, unlike `runCheck` — there is no single cascade to resolve `doctor` against, so it never touches settings-exposure (which only means anything relative to one resolved cascade).
+ *
+ * Every check aggregates rather than throws: a malformed file becomes one `fail` finding for that file, not an aborted report. This is the one place in the codebase that deliberately breaks the "throw a validation error and let it propagate" convention every other command relies on — `doctor`'s whole purpose is to survive a broken file and keep auditing everything else.
+ */
 declare function runDoctor(params: RunDoctorParams): DoctorReport;
 /** Renders a full `DoctorReport` as plain text lines, one section header at a time, in the order `agent-shim doctor` prints them. */
 declare function formatDoctorReport(report: DoctorReport): string[];
@@ -13408,7 +13532,8 @@ type DoorHealthEvent = z.output<typeof DoorHealthEventSchema>;
  * One expiring-quota event: an identity's window with allowance still unspent that is about to reset, published once when the window enters its final span (so a scheduler can spend what would otherwise be lost, the moment spending it is still possible). `resetsAt` is the window's own reset instant; `observedAt` is when the door's tick saw it cross.
  */
 declare const QuotaExpiringEventSchema: z.ZodObject<{
-    identity: z.ZodString;
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
     provider: z.ZodString;
     window: z.ZodEnum<{
         fiveHour: "fiveHour";
@@ -13421,10 +13546,109 @@ declare const QuotaExpiringEventSchema: z.ZodObject<{
 /** One expiring-quota event, as the TypeScript the publisher emits and its consumers handle. */
 type QuotaExpiringEvent = z.output<typeof QuotaExpiringEventSchema>;
 /**
- * The usage source's payload: the snapshot the door just wrote, verbatim, so a consumer sees the quota change or reset in the payload itself rather than the door guessing which of the two a write was. The snapshot schema is the payload schema (identity, observed instant, every provider's state with its windows), the one definition `usage --json` readers already share.
+ * The usage source's payload: the snapshot the door just wrote, verbatim, so a consumer sees a quota change or a reset in the payload itself rather than the door guessing what the two writes were, with the identity it belongs to named both ways. A snapshot is filed by the identity's id, which its `identity` field also holds; `id` repeats it under the name every event uses, and `name` is the identity's name when the door wrote it, absent for a snapshot of an identity no longer stored under that id.
  */
-/** One usage change event, as the TypeScript the publisher emits and its consumers handle: the written snapshot itself, so the snapshot's own schema (`UsageSnapshotSchema`) is this payload's schema rather than a renamed copy. */
-type UsageChangeEvent = UsageSnapshot;
+declare const UsageChangeEventSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    identity: z.ZodString;
+    updatedAt: z.ZodISODateTime;
+    account: z.ZodOptional<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>>;
+    providers: z.ZodRecord<z.ZodString, z.ZodObject<{
+        lastRequestAt: z.ZodOptional<z.ZodISODateTime>;
+        lastStatus: z.ZodOptional<z.ZodNumber>;
+        lastModel: z.ZodOptional<z.ZodString>;
+        rateLimit: z.ZodOptional<z.ZodObject<{
+            observedAt: z.ZodISODateTime;
+            headers: z.ZodRecord<z.ZodString, z.ZodString>;
+            unified: z.ZodOptional<z.ZodObject<{
+                status: z.ZodOptional<z.ZodString>;
+                fiveHour: z.ZodOptional<z.ZodObject<{
+                    utilization: z.ZodOptional<z.ZodNumber>;
+                    resetsAt: z.ZodOptional<z.ZodISODateTime>;
+                    status: z.ZodOptional<z.ZodString>;
+                    graceUtilization: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>;
+                sevenDay: z.ZodOptional<z.ZodObject<{
+                    utilization: z.ZodOptional<z.ZodNumber>;
+                    resetsAt: z.ZodOptional<z.ZodISODateTime>;
+                    status: z.ZodOptional<z.ZodString>;
+                    graceUtilization: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>;
+                sevenDayOverageIncluded: z.ZodOptional<z.ZodObject<{
+                    utilization: z.ZodOptional<z.ZodNumber>;
+                    resetsAt: z.ZodOptional<z.ZodISODateTime>;
+                    status: z.ZodOptional<z.ZodString>;
+                    graceUtilization: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>>;
+                representativeClaim: z.ZodOptional<z.ZodString>;
+                resetAt: z.ZodOptional<z.ZodISODateTime>;
+                overageStatus: z.ZodOptional<z.ZodString>;
+                overageUtilization: z.ZodOptional<z.ZodNumber>;
+                overageResetsAt: z.ZodOptional<z.ZodISODateTime>;
+                overageDisabledReason: z.ZodOptional<z.ZodString>;
+                overageInUse: z.ZodOptional<z.ZodBoolean>;
+                extraUsageSpend: z.ZodOptional<z.ZodObject<{
+                    usedMinor: z.ZodNumber;
+                    limitMinor: z.ZodOptional<z.ZodNumber>;
+                    currency: z.ZodString;
+                }, z.core.$strict>>;
+                fallbackAvailable: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>>;
+            planWindowsUnavailableAt: z.ZodOptional<z.ZodISODateTime>;
+        }, z.core.$strict>>;
+        lastLimit: 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>;
+            observedAt: z.ZodISODateTime;
+            status: z.ZodNumber;
+        }, z.core.$strict>>;
+        quota: z.ZodOptional<z.ZodObject<{
+            observedAt: z.ZodISODateTime;
+            source: z.ZodString;
+            level: z.ZodOptional<z.ZodString>;
+            account: z.ZodOptional<z.ZodObject<{
+                email: z.ZodOptional<z.ZodString>;
+                accountId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+            windows: z.ZodArray<z.ZodObject<{
+                measures: z.ZodString;
+                periodMs: z.ZodOptional<z.ZodNumber>;
+                period: z.ZodOptional<z.ZodString>;
+                utilization: z.ZodNumber;
+                resetsAt: z.ZodOptional<z.ZodISODateTime>;
+                limit: z.ZodOptional<z.ZodNumber>;
+                used: z.ZodOptional<z.ZodNumber>;
+                remaining: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    id: z.ZodString;
+    name: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+/** One usage change event, as the TypeScript the publisher emits and its consumers handle (the schema's own inferred type). */
+type UsageChangeEvent = z.output<typeof UsageChangeEventSchema>;
 
 /**
  * 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.
@@ -14206,6 +14430,7 @@ interface FarmRuntime {
 /** Inputs to `prepareLaunch`: everything a launch needs except the means of spawning the child. */
 interface PrepareLaunchParams {
     readonly paths: LayoutPaths;
+    readonly namesLock?: IdentityNamesLockPorts;
     readonly fs: FsPort;
     readonly proc: ProcPort;
     readonly log: LogPort;
@@ -14266,6 +14491,8 @@ interface LaunchPoolDecision {
 interface LaunchDecision {
     /** The identity the launch runs as. Absent when the escape hatch applied or nothing resolved one. */
     readonly identity?: string;
+    /** The id `identity` is stored under: the directory under the identities directory, which a rename keeps. Absent exactly when `identity` is. */
+    readonly identityId?: string;
     /** Which precedence rule selected the identity (or the pool the identity was picked from). */
     readonly identitySource: IdentityDecisionSource;
     /** The pool pick behind `identity`, when the launch selected a pool. */
@@ -14379,6 +14606,7 @@ declare function createLaunchApiRouter(deps: LaunchApiDeps): {
         }, zod_v4_core.$strict>, zod.ZodObject<{
             decision: zod.ZodObject<{
                 identity: zod.ZodOptional<zod.ZodString>;
+                identityId: zod.ZodOptional<zod.ZodString>;
                 identitySource: zod.ZodEnum<{
                     "config-dir-escape-hatch": "config-dir-escape-hatch";
                     argv: "argv";
@@ -16053,6 +16281,7 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
         }, zod_v4_core.$strict>, zod.ZodObject<{
             decision: zod.ZodObject<{
                 identity: zod.ZodOptional<zod.ZodString>;
+                identityId: zod.ZodOptional<zod.ZodString>;
                 identitySource: zod.ZodEnum<{
                     "config-dir-escape-hatch": "config-dir-escape-hatch";
                     argv: "argv";
@@ -25312,6 +25541,7 @@ declare const LaunchResolveInputSchema: z.ZodObject<{
 declare const LaunchResolveOutputSchema: z.ZodObject<{
     decision: z.ZodObject<{
         identity: z.ZodOptional<z.ZodString>;
+        identityId: z.ZodOptional<z.ZodString>;
         identitySource: z.ZodEnum<{
             "config-dir-escape-hatch": "config-dir-escape-hatch";
             argv: "argv";
@@ -26000,10 +26230,11 @@ interface QuotaExpiringPublisher {
     /** Checks every held window against the clock and publishes each one newly inside its final span. Idempotent within one span; cheap enough for the supervisor's every tick. */
     readonly check: () => void;
 }
-/** Creates the expiring-quota publisher. One per door process, checked on the supervisor's tick. */
+/** Creates the expiring-quota publisher. One per door process, checked on the supervisor's tick. Snapshots are held by identity id, and `nameOf` names the identity of an id when an event is published, so a rename since the snapshot was written shows. */
 declare function createQuotaExpiringPublisher(hub: DoorEventHub, deps: {
     readonly seed: readonly UsageSnapshot[];
     readonly now: () => number;
+    readonly nameOf: (id: string) => string | undefined;
 }): QuotaExpiringPublisher;
 
 /**
@@ -26186,8 +26417,8 @@ declare const RC_SELF_HOST_RECORD_DIR = "rc-selfhost";
 declare const RC_SELF_HOST_RECORD_FILE = "credential.json";
 /** Everything the minting needs, injected so it runs against an in-memory fake filesystem in unit tests. */
 interface RcSelfHostMintDeps {
-    readonly fs: Pick<FarmFs, "readFileUtf8" | "writeFilePrivate" | "mkdirPrivate">;
-    /** The agent-shim identities directory (the mint writes inside `<identitiesDir>/<identity>/`). */
+    readonly fs: Pick<FarmFs, "readFileUtf8" | "readdir" | "writeFilePrivate" | "mkdirPrivate">;
+    /** The agent-shim identities directory (the mint writes inside `<identitiesDir>/<id>/`, the directory of the identity's id). */
     readonly identitiesDir: string;
     /** The door's state directory (the record is written under `<frontdoorDir>/rc-selfhost/`). */
     readonly frontdoorDir: string;
@@ -26433,23 +26664,6 @@ interface RunFrontDoorSupervisorOptions {
  */
 declare function runFrontDoorSupervisor(idleShutdownMinutes: number, ports: FrontDoorSupervisorPorts, options?: RunFrontDoorSupervisorOptions): Promise<number>;
 
-/**
- * The read side of the usage store: pure over an injected filesystem, so the CLI, the library surface and tests all read the same way, and nothing here writes.
- */
-/** The filesystem reads the usage store's readers need. */
-type UsageReadFs = Pick<FarmFs, "readFileUtf8" | "readdir">;
-/** Raised for a snapshot file that exists but does not hold a snapshot of this schema version. */
-declare class UsageSnapshotError extends Error {
-    readonly file: string;
-    constructor(file: string, detail: string);
-}
-/** The path of an identity's snapshot. Throws for an invalid identity name, which could otherwise name a path outside the snapshots directory. */
-declare function snapshotPath(snapshotsDir: string, identity: string): string;
-/** Reads one identity's snapshot: undefined when it has none yet, `UsageSnapshotError` when the file is there but unreadable. */
-declare function readUsageSnapshot(fs: Pick<FarmFs, "readFileUtf8">, snapshotsDir: string, identity: string): UsageSnapshot | undefined;
-/** 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. */
@@ -26675,6 +26889,8 @@ interface IdentitySession extends SessionSummary {
 declare class SessionLookupError extends CliError {
     constructor(message: string);
 }
+/** The configuration directory an identity's sessions live under, by the identity's name: its directory under the identities directory, which is named by the identity's id and so not necessarily by its name. */
+type IdentityConfigDirOf = (identity: string) => string;
 /** Filters for `session list`. */
 interface SessionListFilters {
     /** Only this identity's sessions. */
@@ -26685,7 +26901,7 @@ interface SessionListFilters {
 /**
  * Collects `session list`, read-only: every session of the given identities with its agent and workflow-run counts, newest transcript first. Sessions with nothing to inspect are left out unless `all` is set, because most sessions never spawn an agent and listing them would bury the ones that did.
  */
-declare function collectSessionList(fs: SessionCommandFs, identitiesDir: string, identities: readonly string[], filters: Readonly<SessionListFilters>): readonly IdentitySession[];
+declare function collectSessionList(fs: SessionCommandFs, configDirOf: IdentityConfigDirOf, identities: readonly string[], filters: Readonly<SessionListFilters>): readonly IdentitySession[];
 /** A resolved session: where it is read from and which identities expose it. */
 interface LocatedSession {
     readonly identities: readonly string[];
@@ -26695,14 +26911,14 @@ interface LocatedSession {
 /**
  * Resolves a session id, or an unambiguous prefix of one, across the given identities. Fails with every candidate named when the prefix matches several, so the caller can say which it meant.
  */
-declare function locateSession(fs: SessionCommandFs, identitiesDir: string, identities: readonly string[], query: string, onlyIdentity?: string): LocatedSession;
+declare function locateSession(fs: SessionCommandFs, configDirOf: IdentityConfigDirOf, identities: readonly string[], query: string, onlyIdentity?: string): LocatedSession;
 /** One session resolved and read: the tree and every identity that exposes it. */
 interface SessionView {
     readonly identities: readonly string[];
     readonly tree: SessionAgentTree;
 }
 /** Resolves a session id or prefix and reads its tree: what `session show` and the door's `sessions.show` both answer. */
-declare function showSession(fs: SessionCommandFs, identitiesDir: string, identities: readonly string[], query: string, onlyIdentity?: string): SessionView;
+declare function showSession(fs: SessionCommandFs, configDirOf: IdentityConfigDirOf, identities: readonly string[], query: string, onlyIdentity?: string): SessionView;
 
 /** One quota window's pool-selection facts, in the units a policy reads: fractions of the window, and hours until it resets. */
 interface PoolWindowFacts {
@@ -26972,7 +27188,7 @@ interface UpdateProviderInput {
  * Updates an existing provider definition in place. Throws `ProviderNotFoundError` when it does not exist, and `ConfigValidationError` when the updated definition fails `ProviderSchema`, leaving the file untouched.
  */
 declare function updateProvider(paths: LayoutPaths, name: string, input: UpdateProviderInput): Provider;
-/** Deletes a provider definition. Throws `ProviderNotFoundError` when it does not exist. */
+/** Deletes a provider definition and its file-cached credential, leaving another provider's entry in the same file alone. Throws `ProviderNotFoundError` when it does not exist. */
 declare function removeProvider(paths: LayoutPaths, name: string): void;
 
 /** One pool member entry, whichever form it takes: the plain selector string, or the object form carrying its policy condition. */
@@ -27228,5 +27444,5 @@ declare const OWN_CLI_FILE_NAME = "cli.cjs";
  */
 declare function agentShimCliPath(distDir?: string | undefined): string;
 
-export { AMBIENT_CREDENTIAL_VARS, AgentKindSchema, AgentMetaSchema, AgentNodeSchema, AgentTreesListInputSchema, AgentTreesListOutputSchema, AgentTreesShowInputSchema, AgentTreesShowOutputSchema, CHECK_CREDENTIAL_APPLIES, CODEX_APP_SERVER_GENERATED_AGAINST, CODEX_APP_SERVER_TIMEOUT_MS, CONNECT_INTERCEPT_HOST, CONNECT_INTERCEPT_HOSTS, CONNECT_LIMITS, CONTROL_PATH_PREFIX, CategoryClassificationOverlaySchema, CategoryClassificationSchema, CategoryMapSchema, CheckReportJsonSchema, CheckRunInputSchema, CliError, CodexAccountReadSchema, CodexAppServerProtocolError, CodexAppServerRequestError, CodexAppServerUnavailableError, CodexLogoutOutputSchema, CodexRateLimitsReadSchema, CodexSignInSchema, CodexStatusOutputSchema, ConfigIdentityAddInputSchema, ConfigIdentityAddOutputSchema, ConfigIdentityRemoveInputSchema, ConfigIdentityRemoveOutputSchema, ConfigIdentitySetInputSchema, ConfigIdentitySetOutputSchema, ConfigIdentityUseOutputSchema, ConfigNameInputSchema, ConfigPoolAddInputSchema, ConfigPoolAddOutputSchema, ConfigPoolRemoveInputSchema, ConfigPoolRemoveOutputSchema, ConfigPoolSetInputSchema, ConfigPoolSetOutputSchema, ConfigPoolUseOutputSchema, ConfigProfileAddInputSchema, ConfigProfileAddOutputSchema, ConfigProfileRemoveInputSchema, ConfigProfileRemoveOutputSchema, ConfigProfileSchema, ConfigProfileSetInputSchema, ConfigProfileSetOutputSchema, ConfigProfileUseOutputSchema, ConfigProviderAddInputSchema, ConfigProviderAddOutputSchema, ConfigProviderRemoveInputSchema, ConfigProviderRemoveOutputSchema, ConfigProviderSetInputSchema, ConfigProviderSetOutputSchema, ConfigRuleAddInputSchema, ConfigRuleAddOutputSchema, ConfigRuleRemoveInputSchema, ConfigRuleRemoveOutputSchema, ConfigRuleSetInputSchema, ConfigRuleSetOutputSchema, CredentialCacheSchema, CredentialSchema, CredentialSourceSchema, CredentialSummarySchema, DOOR_EVENT_BUFFER_EVENTS, DOOR_EVENT_SOURCE_RC, DOOR_HEALTH_EVENT_SOURCE, DirectoryRuleAlreadyExistsError, DirectoryRuleMissingTargetError, DirectoryRuleNotFoundError, DirectoryRuleSchema, DirectoryRulesSchema, DoctorFindingSchema, DoctorRunOutputSchema, DoorEventSchema, DoorEventSourceQuerySchema, DoorHealthEventSchema, EXIT_FAILURE, EXIT_USAGE, EffectiveWindowSchema, EntryValueSchema, FARM_MANIFEST_FILENAME, FrontDoorControlMaterialError, FrontDoorNotServingError, FrontDoorRestartOutputSchema, FrontDoorSessionStatusSchema, FrontDoorSessionsOutputSchema, FrontDoorStartError, FrontDoorStateSchema, FrontDoorStatusOutputSchema, GlobalConfigSchema, HeadroomSocketTargetSchema, HeadroomStartError, IdentityAlreadyExistsError, IdentityNotFoundError, IdentitySchema, InvalidCategoryNameError, InvalidIdentityNameError, InvalidProviderNameError, LAUNCH_EVENT_SOURCE, LIVE_TASK_CAP, LaunchLifecycleEventSchema, LaunchRefusedError, LaunchResolveInputSchema, LaunchResolveOutputSchema, LegacyProviderFileError, LiveTaskSchema, MergedAgentNodeSchema, MergedAgentTreeSchema, OWN_CLI_FILE_NAME, PROMPT_CACHE_TTL_MS, PlanClassSchema, PoolGraphError, PoolNameSchema, PoolNotFoundError, PoolPickReportSchema, PoolSchema, PortableConfigSchema, ProfileAlreadyExistsError, ProfileNotFoundError, ProviderAlreadyExistsError, ProviderKindMismatchError, ProviderNotFoundError, ProviderSchema, QUOTA_EXPIRING_EVENT_SOURCE, QuotaExpiringEventSchema, 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, ResetRowSchema, ResetScheduleSchema, SessionAgentTreeSchema, SessionLookupError, SessionSummarySchema, TaskItemSchema, USAGE_EVENT_SOURCE, UpdateCheckOutputSchema, UsageError, UsageListOutputSchema, UsageLiveOutputSchema, UsageSnapshotError, UsageSnapshotSchema, UsageWindowsInputSchema, UsageWindowsOutputSchema, WhenSchema, WorkflowRunSchema, addDirectoryRule, addIdentity, addPool, addProvider, agentShimCliPath, answerRcControlRequest, applyAgentTaskEvent, authenticateRcSessionMcpServer, buildEntryFacts, buildLayoutPaths, buildRcControlRequestPayload, buildRcControlResponsePayload, buildRcEndSessionPayload, buildRcEventWriteBody, buildRcFileSuggestionsPayload, buildRcGetContextUsagePayload, buildRcGetUsagePayload, buildRcInterruptPayload, buildRcKeepAlivePayload, buildRcMarkReadBody, buildRcMcpAuthenticatePayload, buildRcMcpOAuthCallbackUrlPayload, buildRcMcpReconnectPayload, buildRcMcpStatusPayload, buildRcReadFilePayload, buildRcSetModelPayload, buildRcSetPermissionModePayload, buildRcUserMessagePayload, carryOver, changePool, checkReportHasWarnings, checkReportToJson, collectCheckReport, collectDoctorReport, collectFrontDoorStatus, collectPoolPick, collectResets, collectSessionList, createAgentTreesApiRouter, createCodexApiRouter, createConfigApiRouter, createControlApiRouter, createDoorApiNodeHandler, createDoorApiRouter, createDoorEventHub, createDoorHealthPublisher, createEventsApiRouter, createLaunchApiRouter, createLaunchEventPublisher, createLeafCache, createLifecycleApiRouter, createLiveSessionRegistry, createProfile, createQuotaExpiringPublisher, 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, frontDoorApiFromState, frontDoorApiLink, frontDoorRcApiClient, frontDoorRcControl, generateCa, getRcSessionContextUsage, getRcSessionMcpStatus, getRcSessionUsage, headroomSocketTarget, identityExists, injectRcUserMessage, interruptRcSession, isIdentityDirectoryName, isInterceptedHost, isPrivateAddress, isRcContextUsageDetail, isRcPermissionMode, isRcReadFileEncoding, lateRcEventDial, lateRcStreamDial, launchRequiredUpstreams, listDirectoryRules, listIdentities, listProfiles, listProviders, listSessions, listUsageSnapshots, locateSession, matchBranch, mergeLiveTasks, mintLeaf, mintRcSelfHostCredential, observingRoutedRoute, parseConnectTarget, parseRcStreamEnvelope, planOf, poolIdentities, poolSelectedByLaunch, prepareClaudeLaunch, prepareLaunch, profileExists, providerExists, rankPool, rcEventWriteResultFromAnswer, rcFanoutOnDoorHub, rcObserverAsPassthrough, rcRateLimitInfoOf, rcSelfHostFromEnv, rcWebFetchAllowsPrivateFromEnv, readActiveIdentity, readCodexAccount, readCodexRateLimits, readDirectoryRules, readFarmManifest, readFrontDoorControlMaterial, readGlobalConfig, readIdentity, readPools, readProfile, readProvider, readRcSelfHostRecord, readRcSessionFile, readSessionAgentTree, readUsageSnapshot, realCodexAppServerPort, realConnectCertStore, realConnectEffects, realRcControlTransport, realRcEventDial, realRcStreamDial, realRcWebFetch, realSessionFs, reconnectRcSessionMcpServer, recoverFarm, recoveryDiagnostics, refreshLaunchPoolUsage, refreshPoolUsage, refreshStalePoolMembers, removeDirectoryRule, removeIdentity, removePool, removeProfile, removeProvider, requirePool, resolveAgentShimHome, resolveClaudeHome, resolveClaudeLaunch, resolveDecisions, resolveLaunch, resolveLaunchSelection, resolveLayoutPaths, resolveSupervisorConfig, resyncFarm, runCheck, runClaudeLaunch, runDoctor, runFrontDoorSupervisor, runLaunchPlan, runLauncher, runSupervisor, sendRcKeepAlive, servedByPipeline, setAllowAmbientCredential, setDefaultConfigProfile, setGlobalDefaultProfile, setIdentityCredential, setProfileCategories, setProfileEntries, setProfileLaunchFlags, setProfileMetadata, setRcSessionModel, setRcSessionPermissionMode, showSession, snapshotPath, spawnClaude, startConnectServer, submitRcSessionMcpOAuthCallbackUrl, suggestRcSessionFiles, summariseSession, teleportRcSession, topLevelNames, updateDirectoryRule, updateProvider, useIdentity, watchedInstallEntry, writeDirectoryRules };
-export type { AddDirectoryRuleOptions, AddProviderInput, AgentKind, AgentNode, AgentReadFs, AgentTreesApiDeps, AgentTreesApiRouter, AmbientCredentialDetection, AmbientCredentialGuardResult, AmbientCredentialVar, AnthropicUsageRefresher, BuildEntryFactsParams, CaMaterial, Candidate, CarryOverParams, CarryOverResult, CategoryMap, CheckReport, CheckReportJson, ClaudeLaunchResolution, CodexAccountRead, CodexApiClient, CodexApiDeps, CodexApiRouter, CodexAppServerConnection, CodexAppServerPort, CodexAppServerReadOptions, CodexRateLimitsRead, CollectCheckReportParams, CollectDoctorReportParams, CompiledRule, ConditionContext, ConfigApiDeps, ConfigApiRouter, 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, DoorHealthEvent, DoorHealthPublisher, EffectiveWindow, EliminatedRule, EnsureFrontDoorPorts, EnsureHeadroomPorts, EntryFact, EntryFacts, EntryValue, EvaluateAmbientCredentialGuardParams, FlattenedCascade, FrontDoorControlMaterial, FrontDoorRcControl, FrontDoorSessionStatus, FrontDoorStatus, FrontDoorSupervisorPorts, GlobalConfig, HeadroomSupervisorConfig, Identity, IdentityCredentialChange, IdentityListEntry, IdentityListing, IdentitySession, InjectedCredential, LaunchApiDeps, LaunchApiRouter, LaunchDecision, LaunchEventPublisher, LaunchLifecycleEvent, LaunchPlan, LaunchPoolDecision, LaunchResolution, LaunchSelection, Layer, LayerId, LayoutPaths, LeafCert, LifecycleApiClient, LifecycleApiDeps, LifecycleApiRouter, LiveSessionRegistry, LiveSessionRegistryPorts, LiveTask, LiveTaskBook, LocatedSession, MergedAgentNode, MergedAgentTree, NestedContribution, OwnExecutableStat, PlanClass, Pool, PoolChange, PoolMember, PoolPickReport, PoolPolicy, PoolRanking, PortableConfig, PrepareClaudeLaunchOptions, PrepareLaunchParams, ProfileListEntry, Provider, ProviderListEntry, QuotaExpiringEvent, QuotaExpiringPublisher, 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, ReadSessionOptions, RecoverFarmParams, RecoveryResult, RefreshLaunchPoolUsageOptions, RefreshPoolUsageParams, RefreshStalePoolMembersParams, ResetRow, ResetSchedule, ResolveClaudeLaunchOptions, ResolveDecisionsInput, ResolveLaunchSelectionParams, ResolvedState, ResyncFarmParams, ResyncFarmResult, RunCheckParams, RunClaudeLaunchOptions, RunDoctorParams, RunFrontDoorSupervisorOptions, RunLauncherParams, RunSupervisorOptions, SessionAgentTree, SessionCommandFs, SessionListFilters, SessionRef, SessionSummary, SessionView, SpawnClaudeParams, SseParsedEvent, StickyPick, SupervisorPorts, TaskItem, UnreadableIdentityListEntry, UpdateDirectoryRuleOptions, UpdateProviderInput, UsageChangeEvent, UsageReadFs, UsageSnapshot, WhenCondition, WhenEvaluation, WorkflowRun };
+export { AMBIENT_CREDENTIAL_VARS, AgentKindSchema, AgentMetaSchema, AgentNodeSchema, AgentTreesListInputSchema, AgentTreesListOutputSchema, AgentTreesShowInputSchema, AgentTreesShowOutputSchema, CHECK_CREDENTIAL_APPLIES, CODEX_APP_SERVER_GENERATED_AGAINST, CODEX_APP_SERVER_TIMEOUT_MS, CONNECT_INTERCEPT_HOST, CONNECT_INTERCEPT_HOSTS, CONNECT_LIMITS, CONTROL_PATH_PREFIX, CategoryClassificationOverlaySchema, CategoryClassificationSchema, CategoryMapSchema, CheckReportJsonSchema, CheckRunInputSchema, CliError, CodexAccountReadSchema, CodexAppServerProtocolError, CodexAppServerRequestError, CodexAppServerUnavailableError, CodexLogoutOutputSchema, CodexRateLimitsReadSchema, CodexSignInSchema, CodexStatusOutputSchema, ConfigIdentityAddInputSchema, ConfigIdentityAddOutputSchema, ConfigIdentityRemoveInputSchema, ConfigIdentityRemoveOutputSchema, ConfigIdentitySetInputSchema, ConfigIdentitySetOutputSchema, ConfigIdentityUseOutputSchema, ConfigNameInputSchema, ConfigPoolAddInputSchema, ConfigPoolAddOutputSchema, ConfigPoolRemoveInputSchema, ConfigPoolRemoveOutputSchema, ConfigPoolSetInputSchema, ConfigPoolSetOutputSchema, ConfigPoolUseOutputSchema, ConfigProfileAddInputSchema, ConfigProfileAddOutputSchema, ConfigProfileRemoveInputSchema, ConfigProfileRemoveOutputSchema, ConfigProfileSchema, ConfigProfileSetInputSchema, ConfigProfileSetOutputSchema, ConfigProfileUseOutputSchema, ConfigProviderAddInputSchema, ConfigProviderAddOutputSchema, ConfigProviderRemoveInputSchema, ConfigProviderRemoveOutputSchema, ConfigProviderSetInputSchema, ConfigProviderSetOutputSchema, ConfigRuleAddInputSchema, ConfigRuleAddOutputSchema, ConfigRuleRemoveInputSchema, ConfigRuleRemoveOutputSchema, ConfigRuleSetInputSchema, ConfigRuleSetOutputSchema, CredentialCacheSchema, CredentialSchema, CredentialSourceSchema, CredentialSummarySchema, DOOR_EVENT_BUFFER_EVENTS, DOOR_EVENT_SOURCE_RC, DOOR_HEALTH_EVENT_SOURCE, DirectoryRuleAlreadyExistsError, DirectoryRuleMissingTargetError, DirectoryRuleNotFoundError, DirectoryRuleSchema, DirectoryRulesSchema, DoctorFindingSchema, DoctorRunOutputSchema, DoorEventSchema, DoorEventSourceQuerySchema, DoorHealthEventSchema, DuplicateIdentityNameError, EXIT_FAILURE, EXIT_USAGE, EffectiveWindowSchema, EntryValueSchema, FARM_MANIFEST_FILENAME, FrontDoorControlMaterialError, FrontDoorNotServingError, FrontDoorRestartOutputSchema, FrontDoorSessionStatusSchema, FrontDoorSessionsOutputSchema, FrontDoorStartError, FrontDoorStateSchema, FrontDoorStatusOutputSchema, GlobalConfigSchema, HeadroomSocketTargetSchema, HeadroomStartError, IdentityAlreadyExistsError, IdentityNotFoundError, IdentitySchema, InvalidCategoryNameError, InvalidIdentityNameError, InvalidProviderNameError, LAUNCH_EVENT_SOURCE, LIVE_TASK_CAP, LaunchLifecycleEventSchema, LaunchRefusedError, LaunchResolveInputSchema, LaunchResolveOutputSchema, LegacyProviderFileError, LiveTaskSchema, MergedAgentNodeSchema, MergedAgentTreeSchema, OWN_CLI_FILE_NAME, PROMPT_CACHE_TTL_MS, PlanClassSchema, PoolGraphError, PoolNameSchema, PoolNotFoundError, PoolPickReportSchema, PoolSchema, PortableConfigSchema, ProfileAlreadyExistsError, ProfileNotFoundError, ProviderAlreadyExistsError, ProviderKindMismatchError, ProviderNotFoundError, ProviderSchema, QUOTA_EXPIRING_EVENT_SOURCE, QuotaExpiringEventSchema, 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, ResetRowSchema, ResetScheduleSchema, SessionAgentTreeSchema, SessionLookupError, SessionSummarySchema, TaskItemSchema, USAGE_EVENT_SOURCE, UpdateCheckOutputSchema, UsageChangeEventSchema, UsageError, UsageListOutputSchema, UsageLiveOutputSchema, UsageSnapshotError, UsageSnapshotSchema, UsageWindowsInputSchema, UsageWindowsOutputSchema, WhenSchema, WorkflowRunSchema, addDirectoryRule, addIdentity, addPool, addProvider, agentShimCliPath, answerRcControlRequest, applyAgentTaskEvent, authenticateRcSessionMcpServer, buildEntryFacts, buildLayoutPaths, buildRcControlRequestPayload, buildRcControlResponsePayload, buildRcEndSessionPayload, buildRcEventWriteBody, buildRcFileSuggestionsPayload, buildRcGetContextUsagePayload, buildRcGetUsagePayload, buildRcInterruptPayload, buildRcKeepAlivePayload, buildRcMarkReadBody, buildRcMcpAuthenticatePayload, buildRcMcpOAuthCallbackUrlPayload, buildRcMcpReconnectPayload, buildRcMcpStatusPayload, buildRcReadFilePayload, buildRcSetModelPayload, buildRcSetPermissionModePayload, buildRcUserMessagePayload, carryOver, changePool, checkReportHasWarnings, checkReportToJson, collectCheckReport, collectDoctorReport, collectFrontDoorStatus, collectPoolPick, collectResets, collectSessionList, createAgentTreesApiRouter, createCodexApiRouter, createConfigApiRouter, createControlApiRouter, createDoorApiNodeHandler, createDoorApiRouter, createDoorEventHub, createDoorHealthPublisher, createEventsApiRouter, createLaunchApiRouter, createLaunchEventPublisher, createLeafCache, createLifecycleApiRouter, createLiveSessionRegistry, createProfile, createQuotaExpiringPublisher, 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, frontDoorApiFromState, frontDoorApiLink, frontDoorRcApiClient, frontDoorRcControl, generateCa, getRcSessionContextUsage, getRcSessionMcpStatus, getRcSessionUsage, headroomSocketTarget, identityExists, identityIdOf, identityNameOf, identityRecords, injectRcUserMessage, interruptRcSession, isIdentityDirectoryName, isInterceptedHost, isPrivateAddress, isRcContextUsageDetail, isRcPermissionMode, isRcReadFileEncoding, lateRcEventDial, lateRcStreamDial, launchRequiredUpstreams, listDirectoryRules, listIdentities, listProfiles, listProviders, listSessions, listUsageSnapshots, locateSession, matchBranch, mergeLiveTasks, mintLeaf, mintRcSelfHostCredential, observingRoutedRoute, parseConnectTarget, parseRcStreamEnvelope, planOf, poolIdentities, poolSelectedByLaunch, prepareClaudeLaunch, prepareLaunch, profileExists, providerExists, rankPool, rcEventWriteResultFromAnswer, rcFanoutOnDoorHub, rcObserverAsPassthrough, rcRateLimitInfoOf, rcSelfHostFromEnv, rcWebFetchAllowsPrivateFromEnv, readActiveIdentity, readCodexAccount, readCodexRateLimits, readDirectoryRules, readFarmManifest, readFrontDoorControlMaterial, readGlobalConfig, readIdentity, readIdentityById, readIdentityRecords, readPools, readProfile, readProvider, readRcSelfHostRecord, readRcSessionFile, readSessionAgentTree, readUsageSnapshot, realCodexAppServerPort, realConnectCertStore, realConnectEffects, realRcControlTransport, realRcEventDial, realRcStreamDial, realRcWebFetch, realSessionFs, reconnectRcSessionMcpServer, recoverFarm, recoveryDiagnostics, refreshLaunchPoolUsage, refreshPoolUsage, refreshStalePoolMembers, removeDirectoryRule, removeIdentity, removePool, removeProfile, removeProvider, requirePool, resolveAgentShimHome, resolveClaudeHome, resolveClaudeLaunch, resolveDecisions, resolveLaunch, resolveLaunchSelection, resolveLayoutPaths, resolveSupervisorConfig, resyncFarm, runCheck, runClaudeLaunch, runDoctor, runFrontDoorSupervisor, runLaunchPlan, runLauncher, runSupervisor, sendRcKeepAlive, servedByPipeline, setAllowAmbientCredential, setDefaultConfigProfile, setGlobalDefaultProfile, setIdentityCredential, setProfileCategories, setProfileEntries, setProfileLaunchFlags, setProfileMetadata, setRcSessionModel, setRcSessionPermissionMode, showSession, snapshotPath, spawnClaude, startConnectServer, submitRcSessionMcpOAuthCallbackUrl, suggestRcSessionFiles, summariseSession, teleportRcSession, topLevelNames, updateDirectoryRule, updateProvider, useIdentity, watchedInstallEntry, writeDirectoryRules };
+export type { AddDirectoryRuleOptions, AddProviderInput, AgentKind, AgentNode, AgentReadFs, AgentTreesApiDeps, AgentTreesApiRouter, AmbientCredentialDetection, AmbientCredentialGuardResult, AmbientCredentialVar, AnthropicUsageRefresher, BuildEntryFactsParams, CaMaterial, Candidate, CarryOverParams, CarryOverResult, CategoryMap, CheckReport, CheckReportJson, ClaudeLaunchResolution, CodexAccountRead, CodexApiClient, CodexApiDeps, CodexApiRouter, CodexAppServerConnection, CodexAppServerPort, CodexAppServerReadOptions, CodexRateLimitsRead, CollectCheckReportParams, CollectDoctorReportParams, CompiledRule, ConditionContext, ConfigApiDeps, ConfigApiRouter, 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, DoorHealthEvent, DoorHealthPublisher, EffectiveWindow, EliminatedRule, EnsureFrontDoorPorts, EnsureHeadroomPorts, EntryFact, EntryFacts, EntryValue, EvaluateAmbientCredentialGuardParams, FlattenedCascade, FrontDoorControlMaterial, FrontDoorRcControl, FrontDoorSessionStatus, FrontDoorStatus, FrontDoorSupervisorPorts, GlobalConfig, HeadroomSupervisorConfig, Identity, IdentityCredentialChange, IdentityListEntry, IdentityListing, IdentityNameRead, IdentityRecord, IdentityRecordsPort, IdentitySession, InjectedCredential, LaunchApiDeps, LaunchApiRouter, LaunchDecision, LaunchEventPublisher, LaunchLifecycleEvent, LaunchPlan, LaunchPoolDecision, LaunchResolution, LaunchSelection, Layer, LayerId, LayoutPaths, LeafCert, LifecycleApiClient, LifecycleApiDeps, LifecycleApiRouter, LiveSessionRegistry, LiveSessionRegistryPorts, LiveTask, LiveTaskBook, LocatedSession, MergedAgentNode, MergedAgentTree, NestedContribution, OwnExecutableStat, PlanClass, Pool, PoolChange, PoolMember, PoolPickReport, PoolPolicy, PoolRanking, PortableConfig, PrepareClaudeLaunchOptions, PrepareLaunchParams, ProfileListEntry, Provider, ProviderListEntry, QuotaExpiringEvent, QuotaExpiringPublisher, 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, ReadSessionOptions, RecoverFarmParams, RecoveryResult, RefreshLaunchPoolUsageOptions, RefreshPoolUsageParams, RefreshStalePoolMembersParams, ResetRow, ResetSchedule, ResolveClaudeLaunchOptions, ResolveDecisionsInput, ResolveLaunchSelectionParams, ResolvedState, ResyncFarmParams, ResyncFarmResult, RunCheckParams, RunClaudeLaunchOptions, RunDoctorParams, RunFrontDoorSupervisorOptions, RunLauncherParams, RunSupervisorOptions, SessionAgentTree, SessionCommandFs, SessionListFilters, SessionRef, SessionSummary, SessionView, SpawnClaudeParams, SseParsedEvent, StickyPick, SupervisorPorts, TaskItem, UnreadableIdentityListEntry, UpdateDirectoryRuleOptions, UpdateProviderInput, UsageChangeEvent, UsageReadFs, UsageSnapshot, WhenCondition, WhenEvaluation, WorkflowRun };