claude-use 11.89.1 → 12.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -299,12 +299,12 @@ declare const LaunchSchema: z.ZodObject<{
299
299
  header: z.ZodOptional<z.ZodArray<z.ZodEnum<{
300
300
  identity: "identity";
301
301
  model: "model";
302
+ route: "route";
302
303
  account: "account";
303
304
  provider: "provider";
304
305
  version: "version";
305
306
  headroom: "headroom";
306
307
  duration: "duration";
307
- route: "route";
308
308
  project: "project";
309
309
  vcs: "vcs";
310
310
  effort: "effort";
@@ -800,8 +800,8 @@ declare const LaunchSchema: z.ZodObject<{
800
800
  project: z.ZodOptional<z.ZodObject<{
801
801
  pathLevels: z.ZodOptional<z.ZodEnum<{
802
802
  full: "full";
803
- 1: "1";
804
803
  2: "2";
804
+ 1: "1";
805
805
  3: "3";
806
806
  }>>;
807
807
  addedDirsLayout: z.ZodOptional<z.ZodEnum<{
@@ -1529,12 +1529,12 @@ declare const ConfigProfileSchema: z.ZodObject<{
1529
1529
  header: z.ZodOptional<z.ZodArray<z.ZodEnum<{
1530
1530
  identity: "identity";
1531
1531
  model: "model";
1532
+ route: "route";
1532
1533
  account: "account";
1533
1534
  provider: "provider";
1534
1535
  version: "version";
1535
1536
  headroom: "headroom";
1536
1537
  duration: "duration";
1537
- route: "route";
1538
1538
  project: "project";
1539
1539
  vcs: "vcs";
1540
1540
  effort: "effort";
@@ -2030,8 +2030,8 @@ declare const ConfigProfileSchema: z.ZodObject<{
2030
2030
  project: z.ZodOptional<z.ZodObject<{
2031
2031
  pathLevels: z.ZodOptional<z.ZodEnum<{
2032
2032
  full: "full";
2033
- 1: "1";
2034
2033
  2: "2";
2034
+ 1: "1";
2035
2035
  3: "3";
2036
2036
  }>>;
2037
2037
  addedDirsLayout: z.ZodOptional<z.ZodEnum<{
@@ -2379,12 +2379,12 @@ declare const DirectoryRuleSchema: z.ZodObject<{
2379
2379
  header: z.ZodOptional<z.ZodArray<z.ZodEnum<{
2380
2380
  identity: "identity";
2381
2381
  model: "model";
2382
+ route: "route";
2382
2383
  account: "account";
2383
2384
  provider: "provider";
2384
2385
  version: "version";
2385
2386
  headroom: "headroom";
2386
2387
  duration: "duration";
2387
- route: "route";
2388
2388
  project: "project";
2389
2389
  vcs: "vcs";
2390
2390
  effort: "effort";
@@ -2880,8 +2880,8 @@ declare const DirectoryRuleSchema: z.ZodObject<{
2880
2880
  project: z.ZodOptional<z.ZodObject<{
2881
2881
  pathLevels: z.ZodOptional<z.ZodEnum<{
2882
2882
  full: "full";
2883
- 1: "1";
2884
2883
  2: "2";
2884
+ 1: "1";
2885
2885
  3: "3";
2886
2886
  }>>;
2887
2887
  addedDirsLayout: z.ZodOptional<z.ZodEnum<{
@@ -3155,12 +3155,12 @@ declare const DirectoryRulesSchema: z.ZodObject<{
3155
3155
  header: z.ZodOptional<z.ZodArray<z.ZodEnum<{
3156
3156
  identity: "identity";
3157
3157
  model: "model";
3158
+ route: "route";
3158
3159
  account: "account";
3159
3160
  provider: "provider";
3160
3161
  version: "version";
3161
3162
  headroom: "headroom";
3162
3163
  duration: "duration";
3163
- route: "route";
3164
3164
  project: "project";
3165
3165
  vcs: "vcs";
3166
3166
  effort: "effort";
@@ -3656,8 +3656,8 @@ declare const DirectoryRulesSchema: z.ZodObject<{
3656
3656
  project: z.ZodOptional<z.ZodObject<{
3657
3657
  pathLevels: z.ZodOptional<z.ZodEnum<{
3658
3658
  full: "full";
3659
- 1: "1";
3660
3659
  2: "2";
3660
+ 1: "1";
3661
3661
  3: "3";
3662
3662
  }>>;
3663
3663
  addedDirsLayout: z.ZodOptional<z.ZodEnum<{
@@ -3931,12 +3931,12 @@ declare const PortableConfigSchema: z.ZodObject<{
3931
3931
  header: z.ZodOptional<z.ZodArray<z.ZodEnum<{
3932
3932
  identity: "identity";
3933
3933
  model: "model";
3934
+ route: "route";
3934
3935
  account: "account";
3935
3936
  provider: "provider";
3936
3937
  version: "version";
3937
3938
  headroom: "headroom";
3938
3939
  duration: "duration";
3939
- route: "route";
3940
3940
  project: "project";
3941
3941
  vcs: "vcs";
3942
3942
  effort: "effort";
@@ -4432,8 +4432,8 @@ declare const PortableConfigSchema: z.ZodObject<{
4432
4432
  project: z.ZodOptional<z.ZodObject<{
4433
4433
  pathLevels: z.ZodOptional<z.ZodEnum<{
4434
4434
  full: "full";
4435
- 1: "1";
4436
4435
  2: "2";
4436
+ 1: "1";
4437
4437
  3: "3";
4438
4438
  }>>;
4439
4439
  addedDirsLayout: z.ZodOptional<z.ZodEnum<{
@@ -4687,12 +4687,12 @@ declare const GlobalConfigSchema: z.ZodObject<{
4687
4687
  header: z.ZodOptional<z.ZodArray<z.ZodEnum<{
4688
4688
  identity: "identity";
4689
4689
  model: "model";
4690
+ route: "route";
4690
4691
  account: "account";
4691
4692
  provider: "provider";
4692
4693
  version: "version";
4693
4694
  headroom: "headroom";
4694
4695
  duration: "duration";
4695
- route: "route";
4696
4696
  project: "project";
4697
4697
  vcs: "vcs";
4698
4698
  effort: "effort";
@@ -5188,8 +5188,8 @@ declare const GlobalConfigSchema: z.ZodObject<{
5188
5188
  project: z.ZodOptional<z.ZodObject<{
5189
5189
  pathLevels: z.ZodOptional<z.ZodEnum<{
5190
5190
  full: "full";
5191
- 1: "1";
5192
5191
  2: "2";
5192
+ 1: "1";
5193
5193
  3: "3";
5194
5194
  }>>;
5195
5195
  addedDirsLayout: z.ZodOptional<z.ZodEnum<{
@@ -6938,8 +6938,8 @@ declare function createRcCredentialStore(fs: FarmFs, dir: string): RcCredentialS
6938
6938
 
6939
6939
  /** Why the tracker stopped describing a session: its liveness bound passed with no traffic, an accepted archive ended it by design, or the service closed it with a conflict header. */
6940
6940
  declare const RC_SESSION_END_REASONS: readonly ["expired", "archived", "conflict"];
6941
- /** Why a control request stopped awaiting an answer: a `control_response` answered it (whoever sent it), its answer deadline passed, or its session ended with it still outstanding. */
6942
- declare const RC_PENDING_RETIRE_REASONS: readonly ["answered", "expired", "session-ended"];
6941
+ /** Why a control request stopped awaiting an answer: a `control_response` answered it (whoever sent it), the worker withdrew it with a `control_cancel_request` (it was resolved in the session's own terminal), a worker registration reported the worker no longer waiting on it, or its session ended with it still outstanding. The worker sets no answer deadline, so none of these is a timeout. */
6942
+ declare const RC_PENDING_RETIRE_REASONS: readonly ["answered", "withdrawn", "worker-stopped", "session-ended"];
6943
6943
  /** One reason a session ended. */
6944
6944
  type RcSessionEndReason = (typeof RC_SESSION_END_REASONS)[number];
6945
6945
  /** One reason a pending request retired. */
@@ -6977,9 +6977,10 @@ declare const RcSessionTransitionSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
6977
6977
  kind: z.ZodLiteral<"pending-retired">;
6978
6978
  requestId: z.ZodString;
6979
6979
  reason: z.ZodEnum<{
6980
- expired: "expired";
6981
6980
  "session-ended": "session-ended";
6982
6981
  answered: "answered";
6982
+ withdrawn: "withdrawn";
6983
+ "worker-stopped": "worker-stopped";
6983
6984
  }>;
6984
6985
  }, z.core.$strict>], "kind">;
6985
6986
  /** One transition as the tracker hands it to the log's sink. */
@@ -7029,9 +7030,10 @@ declare const RcSessionEventSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
7029
7030
  kind: z.ZodLiteral<"pending-retired">;
7030
7031
  requestId: z.ZodString;
7031
7032
  reason: z.ZodEnum<{
7032
- expired: "expired";
7033
7033
  "session-ended": "session-ended";
7034
7034
  answered: "answered";
7035
+ withdrawn: "withdrawn";
7036
+ "worker-stopped": "worker-stopped";
7035
7037
  }>;
7036
7038
  cursor: z.ZodString;
7037
7039
  sequence: z.ZodInt;
@@ -7104,9 +7106,10 @@ declare const RcSessionEventsReadOutputSchema: z.ZodDiscriminatedUnion<[z.ZodObj
7104
7106
  kind: z.ZodLiteral<"pending-retired">;
7105
7107
  requestId: z.ZodString;
7106
7108
  reason: z.ZodEnum<{
7107
- expired: "expired";
7108
7109
  "session-ended": "session-ended";
7109
7110
  answered: "answered";
7111
+ withdrawn: "withdrawn";
7112
+ "worker-stopped": "worker-stopped";
7110
7113
  }>;
7111
7114
  cursor: z.ZodString;
7112
7115
  sequence: z.ZodInt;
@@ -7161,6 +7164,29 @@ declare function followRcSessionEvents(log: RcSessionEventLog, input: Readonly<{
7161
7164
  session?: string | undefined;
7162
7165
  }>, signal?: AbortSignal): AsyncGenerator<RcSessionEvent, void>;
7163
7166
 
7167
+ /** One option of an observed question. */
7168
+ interface RcQuestionOption {
7169
+ readonly label: string;
7170
+ /** The option's helper text, when the question carried one. */
7171
+ readonly description?: string;
7172
+ }
7173
+ /** One question of an observed `AskUserQuestion` request, as the pending surfaces list it. */
7174
+ interface RcPendingQuestion {
7175
+ /** The question text, which is also the key its answer is filed under. */
7176
+ readonly question: string;
7177
+ /** The short tab label the dialog shows, when the question carried one. */
7178
+ readonly header?: string;
7179
+ /** Whether more than one option may be chosen. */
7180
+ readonly multiSelect: boolean;
7181
+ readonly options: readonly RcQuestionOption[];
7182
+ }
7183
+ /**
7184
+ * One selection a caller makes for one question: an option's label (matched exactly, or case-insensitively when that names exactly one option), its one-based number in the order the question lists its options (the numbering the dialog itself shows), or free text in place of an option (the dialog's own "Type something" row).
7185
+ */
7186
+ type RcQuestionSelection = string | number | {
7187
+ readonly text: string;
7188
+ };
7189
+
7164
7190
  /**
7165
7191
  * The Zod schemas of the Remote Control surfaces: one definition each for the summaries, statuses and pending lists the tracker produces, the stream events the door's client attachment fans out, and every input and output the typed API accepts. The tracker's own TypeScript interfaces in `rcSessions.ts` stay the implementations' types; these schemas are what the oRPC contract validates through, and because the procedures wrap the very operations that produce those interfaces' values, a drift between a schema and its interface fails the API's own output validation (exercised by its tests) rather than shipping silently. This module deliberately imports nothing from oRPC: it is a plain Zod leaf, so the tracker and the stream half can share it without either depending on the API layer.
7166
7192
  */
@@ -7349,10 +7375,6 @@ declare const RC_SESSIONS_PATH_PREFIX = "/v1/code/sessions";
7349
7375
  * How long an entry survives without any observed exchange for its session. Derived from the protocol's own liveness, not chosen: the worker heartbeats every 20 s (the `current_interval_seconds` our own captured heartbeat body carries), so a live session produces observable traffic at least that often, and the transport's documented liveness bound is the 45 s stream timeout, which outlasts two missed heartbeat intervals (40 s) precisely so a momentarily quiet session is not dropped. An entry idle past 45 s therefore names a session the protocol itself has given up on, which makes 45 s the exact bound where retaining it stops describing anything live.
7350
7376
  */
7351
7377
  declare const RC_IDLE_EXPIRY_MS = 45000;
7352
- /**
7353
- * How long a control request stays answerable once observed. The protocol's own permission round-trip is documented at roughly 10 to 14 seconds end to end, so the ceiling of that window is the exact bound after which the worker has already given up waiting: answering later would write a `control_response` nothing is waiting for. A request exactly at the bound is already too late, which is why expiry is `>=` and not `>`.
7354
- */
7355
- declare const RC_PENDING_DEADLINE_MS = 14000;
7356
7378
  /**
7357
7379
  * How much of one request body the tracker ever holds while parsing it. The protocol's own batch cap is 10 MiB, but that bound exists to admit bulk transcript events the tracker has no use for; what it reads out of a body (the control requests, the heartbeat's idle, the worker's state) is one control exchange's worth of JSON, the same notion of "a full exchange's body" the capture's per-exchange budget (`STREAM_LOG_CAP_BYTES`, 256 KiB) was sized for, so one budget serves both here. A body past it is skipped, never failed: the exchange flows on untouched and simply records nothing.
7358
7380
  */
@@ -7366,6 +7388,12 @@ interface RcPendingRequestSummary {
7366
7388
  readonly type: string;
7367
7389
  /** A short human-readable sketch: the tool name and a bounded excerpt of its input for `can_use_tool`. */
7368
7390
  readonly summary: string;
7391
+ /** The questions the agent put to the user, in the order it asked them, when the request is the question dialog (a `can_use_tool` request for `AskUserQuestion`); absent for every other request. An answer chooses among exactly these options. */
7392
+ readonly questions?: readonly RcPendingQuestion[];
7393
+ /** Present and true when the request is a question whose payload was past the door's parse cap: only its summary is held, so it shows no questions and cannot be answered through the door. */
7394
+ readonly oversized?: true;
7395
+ /** Present when the request is the question dialog but the door cannot answer it (why, in words): answer it in the session instead. */
7396
+ readonly unanswerable?: string;
7369
7397
  /** When the request was observed, in epoch milliseconds from the injected clock. */
7370
7398
  readonly observedAt: number;
7371
7399
  }
@@ -7392,6 +7420,8 @@ interface RcSessionStatus extends RcSessionSummary {
7392
7420
  readonly pid?: number;
7393
7421
  /** The session's working directory, from its init event or else the registry. */
7394
7422
  readonly cwd?: string;
7423
+ /** How many control requests the door did not list because the session already held `RC_PENDING_PER_SESSION_MAX` or their id was not one the protocol mints; present only when some were. */
7424
+ readonly pendingDropped?: number;
7395
7425
  }
7396
7426
  /** One observed session as the control surface lists it: the identification and timing only, never the credential. */
7397
7427
  interface RcSessionSummary {
@@ -7441,7 +7471,7 @@ interface RcSessionTracker {
7441
7471
  readonly list: () => readonly RcSessionSummary[];
7442
7472
  /** Every live entry as the status surface reports it, with the same sweeping and order as `list`, filtered to one session when named. */
7443
7473
  readonly statusOf: (sessionId?: string) => readonly RcSessionStatus[];
7444
- /** Every control request awaiting an answer, deadline-expired ones dropped first, oldest-observed first, filtered to one session when named. */
7474
+ /** Every control request awaiting an answer, idle sessions expired first, oldest-observed first, filtered to one session when named. */
7445
7475
  readonly pendingOf: (sessionId?: string) => readonly RcPendingRequestSummary[];
7446
7476
  /** The observed credential and protocol headers for one session, the client-half writes' accessor: present only while the session is tracked, and never surfaced anywhere a summary, log or capture goes. */
7447
7477
  readonly credentialOf: (sessionId: string) => RcObservedCredential | undefined;
@@ -7450,13 +7480,17 @@ interface RcSessionTracker {
7450
7480
  /** The session's sequence cursor: the highest number the door has seen, from the client read stream's envelopes or from its own confirmed writes; undefined while neither has been seen. */
7451
7481
  readonly sequenceNumOf: (sessionId: string) => number | undefined;
7452
7482
  /**
7453
- * Files one client read stream envelope: advances the session's sequence cursor, and treats the payload exactly as an observed event-batch body's would be treated, which is how an approval reaches the pending list from the stream (the live finding behind the client attachment: the CLI routes `control_request`s only toward attached clients, so the stream, not the worker's own writes, is where a `can_use_tool` the door must answer becomes visible). A `control_request` whose envelope names the worker as its source births a pending entry; a `control_response` retires the request it answers, whoever answered it.
7483
+ * Files one client read stream envelope: advances the session's sequence cursor, and treats the payload exactly as an observed event-batch body's would be treated, which is how an approval reaches the pending list from the stream (the live finding behind the client attachment: the CLI routes `control_request`s only toward attached clients, so the stream, not the worker's own writes, is where a `can_use_tool` the door must answer becomes visible). A `control_request` whose envelope names the worker as its source births a pending entry; a `control_response` retires the request it answers, whoever answered it; and a `control_cancel_request` from the worker retires the request it withdraws.
7454
7484
  */
7455
7485
  readonly fileStreamEvent: (sessionId: string, event: RcStreamEnvelope) => void;
7456
7486
  /** The live background tasks and subagents the observed events described, for one session or every tracked one, each carrying the session that reported it and when it was last observed. */
7457
7487
  readonly liveTasksOf: (sessionId?: string) => readonly LiveTask[];
7458
7488
  /** Retires one pending control request as answered: what a successful answer write calls, so the request stops being listed the moment it is answered. */
7459
7489
  readonly completePending: (sessionId: string, requestId: string) => void;
7490
+ /** Claims one pending request for an answer in flight, so two answers written at once cannot both reach the worker: returns the release to call once the write has settled, or undefined when the request is not pending or another answer already holds it. */
7491
+ readonly claimPending: (sessionId: string, requestId: string) => (() => void) | undefined;
7492
+ /** The input a pending question request carried, exactly as the worker sent it: the answer path's accessor, since an answer to a question carries that input back with its answers added. Undefined when the request is not pending or is not a question. Never surfaced in a listing. */
7493
+ readonly pendingToolInputOf: (sessionId: string, requestId: string) => Record<string, unknown> | undefined;
7460
7494
  /** Stops the idle sweep timer and tells the transition sink's owner (`onClose`) that no more transitions follow. The entries themselves are unreachable the moment the door drops them. */
7461
7495
  readonly close: () => void;
7462
7496
  }
@@ -7534,19 +7568,21 @@ interface RcInjectDeps {
7534
7568
  readonly newUuid: () => string;
7535
7569
  }
7536
7570
  /**
7537
- * Injects one user-message prompt into an observed session: the documented client-half write, `POST /v1/code/sessions/{id}/events`, authenticated by the observed bearer and carrying the observed protocol headers. The result is the sequence numbers the real service assigned, or a verbose failure. A dial that cannot reach the API host is reported rather than thrown, so a caller with no exception handling still shows the user exactly what failed.
7571
+ * Injects one user-message prompt into an observed session: the documented client-half write, `POST /v1/code/sessions/{id}/events`, authenticated by the observed bearer and carrying the observed protocol headers, the observed `anthropic-client-platform` included, so the door never names an app it is not. The result is the sequence numbers the real service assigned, or a verbose failure. A dial that cannot reach the API host is reported rather than thrown, so a caller with no exception handling still shows the user exactly what failed.
7538
7572
  */
7539
7573
  declare function injectRcUserMessage(deps: RcInjectDeps, sessionId: string, text: string): Promise<RcEventWriteResult>;
7540
- /** The decision an answer carries: approve or deny, with the message a denial shows the worker (the protocol's allow result has no text field, so an approval carries none). */
7574
+ /** The decision an answer carries: approve or deny, with the message a denial shows the worker (the protocol's allow result has no text field, so an approval carries none), and for a question the options chosen. */
7541
7575
  interface RcAnswerDecision {
7542
7576
  readonly approve: boolean;
7543
7577
  /** The denial message; undefined means the protocol's empty default. Present only with a denial. */
7544
7578
  readonly message: string | undefined;
7579
+ /** For a pending question, the selections for each question in the order the request asked them; an approval of a question must carry them, and nothing else may. */
7580
+ readonly choices?: readonly (readonly RcQuestionSelection[])[];
7545
7581
  }
7546
7582
  /**
7547
- * Builds the `control_response` payload event for one answer: the SDK's response envelope, `subtype: "success"` with the request's id echoed in `request_id`, carrying the permission result the worker is waiting for (`behavior: "allow"`, or `"deny"` with its message).
7583
+ * Builds the `control_response` payload event for one answer: the SDK's response envelope, `subtype: "success"` with the request's id echoed in `request_id`, carrying the permission result the worker is waiting for (`behavior: "allow"`, or `"deny"` with its message). An allow that answers a question carries `updatedInput`: the input the worker asked with, plus the `answers` the tool reads.
7548
7584
  */
7549
- declare function buildRcControlResponsePayload(requestId: string, decision: RcAnswerDecision): Record<string, unknown>;
7585
+ declare function buildRcControlResponsePayload(requestId: string, decision: RcAnswerDecision, updatedInput?: Record<string, unknown>): Record<string, unknown>;
7550
7586
  /**
7551
7587
  * The permission modes the SDK's own `set_permission_mode` control request accepts: exactly the strings its `PermissionMode` type declares (`@anthropic-ai/claude-agent-sdk` `sdk.d.ts`), nothing looser. A runtime list as well as a type, because the CLI and the control route both narrow untrusted strings through it before a write is ever attempted.
7552
7588
  */
@@ -7642,13 +7678,17 @@ interface RcAnswerDeps {
7642
7678
  readonly pendingOf: (sessionId: string) => readonly RcPendingRequestSummary[];
7643
7679
  /** Retires a pending request as answered: the tracker's accessor, in production, called only once the write is confirmed delivered. */
7644
7680
  readonly completePending: (sessionId: string, requestId: string) => void;
7681
+ /** Claims the request for this answer while it is written, the tracker's accessor in production: undefined means another answer is already being written for it. */
7682
+ readonly claimPending: (sessionId: string, requestId: string) => (() => void) | undefined;
7683
+ /** Reads the input a pending question was asked with: the tracker's accessor, in production, which an answer carries back with its answers added. */
7684
+ readonly pendingToolInputOf: (sessionId: string, requestId: string) => Record<string, unknown> | undefined;
7645
7685
  /** Advances the session's sequence cursor: the tracker's accessor, in production, so a delivered write's numbers are what a stream resume continues after. */
7646
7686
  readonly noteSequenceNums: (sessionId: string, sequenceNums: readonly number[]) => void;
7647
7687
  /** The dial to the real API host. */
7648
7688
  readonly dial: RcEventDial;
7649
7689
  }
7650
7690
  /**
7651
- * Answers one pending control request on an observed session: the same documented client-half write the inject path performs, carrying a `control_response` that echoes the request's id, authenticated by the observed bearer and protocol headers. The request must still be pending (an answered or deadline-expired request is refused verbosely, since writing a response nothing waits for would mislead the caller), and a successful write retires it. A dial that cannot reach the API host is reported rather than thrown.
7691
+ * Answers one pending control request on an observed session: the same documented client-half write the inject path performs, carrying a `control_response` that echoes the request's id, authenticated by the observed bearer and protocol headers. The request must still be pending (an answered or withdrawn request is refused verbosely, since writing a response nothing waits for would mislead the caller), and a successful write retires it. A question is answered by choosing options, which the write carries as the tool's `answers` beside the input the worker asked with; denying a question dismisses it. A dial that cannot reach the API host is reported rather than thrown.
7652
7692
  */
7653
7693
  declare function answerRcControlRequest(deps: RcAnswerDeps, sessionId: string, requestId: string, decision: RcAnswerDecision): Promise<RcEventWriteResult>;
7654
7694
  /** Everything one client-originated control request needs, injected so the decision logic runs against fakes in unit tests. */
@@ -8060,6 +8100,143 @@ interface FrontDoorRcControl {
8060
8100
  /** Builds the control client: every request presents the control token, and a non-2xx answer becomes the verbose message the door sent with it. */
8061
8101
  declare function frontDoorRcControl(transport: RcControlTransport, token: string): FrontDoorRcControl;
8062
8102
 
8103
+ /** 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. */
8104
+ declare const CachedCredentialSchema: z.ZodObject<{
8105
+ token: z.ZodString;
8106
+ fetchedAt: z.ZodNumber;
8107
+ source: z.ZodUnion<readonly [z.ZodObject<{
8108
+ env: z.ZodString;
8109
+ }, z.core.$strict>, z.ZodObject<{
8110
+ file: z.ZodString;
8111
+ }, z.core.$strict>, z.ZodObject<{
8112
+ interactive: z.ZodOptional<z.ZodBoolean>;
8113
+ timeoutMs: z.ZodOptional<z.ZodInt>;
8114
+ command: z.ZodTuple<[z.ZodString], z.ZodString>;
8115
+ }, z.core.$strict>, z.ZodObject<{
8116
+ interactive: z.ZodOptional<z.ZodBoolean>;
8117
+ timeoutMs: z.ZodOptional<z.ZodInt>;
8118
+ op: z.ZodString;
8119
+ }, z.core.$strict>, z.ZodObject<{
8120
+ interactive: z.ZodOptional<z.ZodBoolean>;
8121
+ timeoutMs: z.ZodOptional<z.ZodInt>;
8122
+ keychain: z.ZodObject<{
8123
+ service: z.ZodString;
8124
+ account: z.ZodOptional<z.ZodString>;
8125
+ }, z.core.$strict>;
8126
+ }, z.core.$strict>, z.ZodObject<{
8127
+ literal: z.ZodString;
8128
+ }, z.core.$strict>]>;
8129
+ owner: z.ZodOptional<z.ZodString>;
8130
+ }, z.core.$strict>;
8131
+ type CachedCredential = z.infer<typeof CachedCredentialSchema>;
8132
+ /**
8133
+ * Where cached credentials live, injected so resolution and its tests need neither the Keychain nor a real directory. `owner` names what the credential belongs to (`identity work`, `provider z`) and is the entry's key; `store` picks the backing store. `read` returns undefined for a missing or unreadable entry, since an entry that cannot be used is the same as no entry.
8134
+ */
8135
+ interface CredentialCachePort {
8136
+ readonly read: (store: CredentialCacheStore, owner: string) => CachedCredential | undefined;
8137
+ readonly write: (store: CredentialCacheStore, owner: string, entry: CachedCredential) => void;
8138
+ readonly remove: (store: CredentialCacheStore, owner: string) => void;
8139
+ }
8140
+ /**
8141
+ * 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.
8142
+ */
8143
+ type CachedCredentialState = {
8144
+ readonly store: CredentialCacheStore;
8145
+ readonly status: "empty";
8146
+ }
8147
+ /** 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. */
8148
+ | {
8149
+ readonly store: CredentialCacheStore;
8150
+ readonly status: "unreadable";
8151
+ readonly reason: string;
8152
+ } | {
8153
+ readonly store: CredentialCacheStore;
8154
+ readonly status: "fresh" | "expired";
8155
+ readonly ageMs: number;
8156
+ readonly expiresInMs?: number;
8157
+ };
8158
+
8159
+ /** 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. */
8160
+ type SecretFileRead = {
8161
+ readonly found: false;
8162
+ } | {
8163
+ readonly found: true;
8164
+ readonly content: string;
8165
+ readonly mode: number | undefined;
8166
+ };
8167
+ /** The outcome of one credential command. `stderr` is empty for an interactive run, whose stderr goes to the terminal so a person sees any prompt. */
8168
+ interface CredentialCommandResult {
8169
+ readonly status: number | null;
8170
+ readonly stdout: string;
8171
+ readonly stderr: string;
8172
+ readonly timedOut: boolean;
8173
+ }
8174
+ /**
8175
+ * Everything resolving a credential needs from the outside world, injected so the resolver (and every launcher test) runs without `op`, the Keychain, real secret files or a terminal. `src/realPorts.ts` wires the real one; tests wire a fake.
8176
+ */
8177
+ interface CredentialPort {
8178
+ /** Reads a `file` source's path (absolute or `~`-rooted). */
8179
+ readonly readSecretFile: (filePath: string) => SecretFileRead;
8180
+ /** Runs a command source's argv directly (no shell) under a timeout, capturing stdout. An interactive run inherits the terminal's stdin and stderr so a person can answer a prompt. */
8181
+ readonly runCommand: (argv: readonly [string, ...string[]], options: {
8182
+ readonly timeoutMs: number;
8183
+ readonly interactive: boolean;
8184
+ }) => CredentialCommandResult;
8185
+ /** Whether a person can answer a prompt now: standard input is a terminal, or there is a desktop session to show a dialog in. */
8186
+ readonly personPresent: () => boolean;
8187
+ /** Where cached credentials live, used only for a credential block that asks for caching. Omit to resolve every launch from the sources. */
8188
+ readonly cache?: CredentialCacheEnv;
8189
+ }
8190
+ /** One source as `check`, `doctor` and every `--json` output report it: its kind plus the same non-secret identifying detail `describeSource` prints. */
8191
+ type CredentialSourceSummary = {
8192
+ readonly kind: "env";
8193
+ readonly variable: string;
8194
+ } | {
8195
+ readonly kind: "file";
8196
+ readonly path: string;
8197
+ } | {
8198
+ readonly kind: "command";
8199
+ readonly program: string;
8200
+ } | {
8201
+ readonly kind: "op";
8202
+ readonly reference: string;
8203
+ } | {
8204
+ readonly kind: "keychain";
8205
+ readonly service: string;
8206
+ readonly account?: string;
8207
+ } | {
8208
+ readonly kind: "literal";
8209
+ };
8210
+ /** A credential block as it is reported: its effective target and each source's summary, in order. */
8211
+ interface CredentialSummary {
8212
+ readonly target: CredentialTarget;
8213
+ readonly sources: readonly CredentialSourceSummary[];
8214
+ /** The block's cache setting when it asks for caching: how long a token is kept (absent for no expiry) and where. Carried as the config schema's own type, since the summary passes the parsed block's setting through unchanged. */
8215
+ readonly cache?: CredentialCache;
8216
+ }
8217
+ /** What caching a credential needs beyond the block's own `cache` setting: the port holding entries, the platform that picks the default store, and the clock the TTL is measured on. */
8218
+ interface CredentialCacheEnv {
8219
+ readonly port: CredentialCachePort;
8220
+ readonly platform: NodeJS.Platform;
8221
+ readonly now: () => number;
8222
+ }
8223
+
8224
+ /** The result of a successful discovery. */
8225
+ interface DiscoveredClaudeBinary {
8226
+ /** Full path to the discovered `claude` executable. */
8227
+ path: string;
8228
+ /** Which strategy found it. */
8229
+ source: "versions-dir" | "path-fallback";
8230
+ /** The version string, when discovered via the versions directory. */
8231
+ version?: string;
8232
+ }
8233
+ /** What a launch asks binary discovery for: nothing (the highest installed version) or an exact version. */
8234
+ interface ClaudeBinaryRequest {
8235
+ readonly version?: string;
8236
+ }
8237
+ /** Discovers the real `claude` binary to spawn, for the version a launch asked for. Injected into the launcher so it never reads the filesystem or PATH itself. */
8238
+ type ClaudeBinaryResolver = (request?: Readonly<ClaudeBinaryRequest>) => DiscoveredClaudeBinary;
8239
+
8063
8240
  /** What an `lstat` (which never follows symlinks) reports about one path, narrowed to what authenticating the socket needs. */
8064
8241
  interface SocketPathStat {
8065
8242
  readonly kind: "dir" | "file" | "socket" | "symlink" | "other";
@@ -8093,6 +8270,245 @@ interface AllowlistFileProblem {
8093
8270
  readonly repairable: boolean;
8094
8271
  }
8095
8272
 
8273
+ /** The outcome of one external command, as `RunPort` reports it. */
8274
+ interface ReplayRunResult {
8275
+ readonly status: number | null;
8276
+ readonly stdout: string;
8277
+ readonly stderr: string;
8278
+ }
8279
+ /** Runs an external command without blocking the calling thread. */
8280
+ type AsyncRun = (command: string, args: readonly string[]) => Promise<ReplayRunResult>;
8281
+
8282
+ /** The effects a hold needs, so it runs against fakes in tests. */
8283
+ interface HoldPort {
8284
+ /** Whether a person is watching: standard input and standard output are both terminals. A launch nobody watches is never held. */
8285
+ readonly attended: () => boolean;
8286
+ /** Blocks for `ms` milliseconds. */
8287
+ readonly sleep: (ms: number) => void;
8288
+ /** Blocks until one key is pressed, and says whether it was the interrupt key (Ctrl-C), which a terminal in the mode this reads in delivers as a byte and not as a signal. */
8289
+ readonly waitForKey: () => "key" | "interrupt";
8290
+ }
8291
+ /** What a hold decided: carry on with the launch, or the person cancelled it. */
8292
+ type HoldOutcome = "go" | "cancelled";
8293
+
8294
+ /** What a compaction came to. A failure is thrown. */
8295
+ type CompactionResult = {
8296
+ readonly kind: "compacted";
8297
+ readonly beforeTokens?: number;
8298
+ readonly afterTokens?: number;
8299
+ } | {
8300
+ readonly kind: "unchanged";
8301
+ readonly reason: string;
8302
+ };
8303
+
8304
+ /**
8305
+ * A session's `/goal` as its transcript records it, read with no effect on the session: Claude Code keeps no goal state anywhere a process outside it can ask, so the transcript is the one source a reader has.
8306
+ *
8307
+ * Every goal change is a `goal_status` attachment row (`{"type":"attachment","attachment":{"type":"goal_status",...}}`), as the 2.1.319 CLI writes them and as its own resume restores a goal from them: setting a goal writes `{ met: false, sentinel: true, condition }`; clearing it writes `{ met: true, sentinel: true, condition }`; each evaluation the goal check makes and finds not yet met writes `{ met: false, condition, reason }`; a met goal writes `met: true` and a failed one `failed: true`, both ending it. The rows are read in order, so the last change wins.
8308
+ */
8309
+ /** One goal as the transcript records it: the condition, how many turns the goal check has evaluated it on, and the check's last stated reason when it has given one. */
8310
+ interface TranscriptGoal {
8311
+ readonly condition: string;
8312
+ readonly iterations: number;
8313
+ readonly lastCheck?: string;
8314
+ }
8315
+
8316
+ /** The brand only `rcSelfHostEventDial` puts on a dial: not exported, so no other code can make a value of the type. */
8317
+ declare const SELF_HOST_DIAL: unique symbol;
8318
+ /**
8319
+ * A dial that reaches the door's own self-hosted surface and nothing else: the one dial a command written as a person's app may ride. Unlike the client half's other dials (`lateRcEventDial`), which fall back to the real API host while no target is resolved, this one refuses: a write whose target is not resolved, or resolves to anything but a loopback address, is never sent.
8320
+ */
8321
+ interface RcSelfHostEventDial {
8322
+ readonly [SELF_HOST_DIAL]: true;
8323
+ readonly writeEvents: RcEventDial["writeEvents"];
8324
+ }
8325
+ /** What a person's-app write needs: the client half's credential accessors and id minting, and the self-hosted dial in place of the general one. */
8326
+ type RcPersonWriteDeps = Omit<RcInjectDeps, "dial"> & {
8327
+ readonly dial: RcSelfHostEventDial;
8328
+ };
8329
+ /** Everything the self-hosted route needs, injected so it runs against fakes in unit tests. */
8330
+ interface RcSelfHostCommandDeps {
8331
+ /** What writing a command as a person's app needs, its dial the door's own surface alone. */
8332
+ readonly personWrite: RcPersonWriteDeps;
8333
+ /** Why the door's own surface cannot take a command now (it is not bound, as when the door runs self-hosted without a transparent surface), or undefined when it can. */
8334
+ readonly unavailable: () => string | undefined;
8335
+ /** The client attachment's fan-out, on which the worker's answer arrives. */
8336
+ readonly fanout: RcEventFanout;
8337
+ /** The Claude Code version the session's worker last reported in a `system/init`, or undefined when none has been observed. */
8338
+ readonly versionOf: (sessionId: string) => string | undefined;
8339
+ /** Arms one timer, returning the function that cancels it: `setTimeout` in production, a controllable clock in tests. */
8340
+ readonly setTimer: (action: () => void, ms: number) => () => void;
8341
+ /** How long to wait when the caller names no bound. */
8342
+ readonly defaultWaitMs: number;
8343
+ }
8344
+ /** One command this route runs. */
8345
+ type RcSelfHostCommand = {
8346
+ readonly kind: "goal-get";
8347
+ } | {
8348
+ readonly kind: "goal-set";
8349
+ readonly condition: string;
8350
+ } | {
8351
+ readonly kind: "goal-clear";
8352
+ } | {
8353
+ readonly kind: "compact";
8354
+ readonly instructions: string | undefined;
8355
+ };
8356
+ /** What each command reports. */
8357
+ interface RcSelfHostReports {
8358
+ readonly "goal-get": {
8359
+ readonly goal: {
8360
+ readonly condition: string;
8361
+ readonly iterations: number;
8362
+ readonly lastCheck?: string;
8363
+ } | null;
8364
+ };
8365
+ readonly "goal-set": {
8366
+ readonly condition: string;
8367
+ };
8368
+ readonly "goal-clear": {
8369
+ readonly cleared: string | null;
8370
+ };
8371
+ readonly compact: {
8372
+ readonly trigger: string;
8373
+ readonly preTokens: number;
8374
+ readonly postTokens: number;
8375
+ };
8376
+ }
8377
+ type ReportOf<C extends RcSelfHostCommand> = RcSelfHostReports[C["kind"]];
8378
+ /** One local command's answer as the worker emitted it: its output text and, when the worker stated it, the outcome kind. */
8379
+ interface LocalCommandAnswer {
8380
+ readonly text: string;
8381
+ readonly outcome: string | undefined;
8382
+ }
8383
+ /** The worker's answer to the local command `command` run with exactly `args`, when this stream event is that answer. */
8384
+ declare function rcLocalCommandAnswerOf(event: RcStreamEvent, command: string, args: string): LocalCommandAnswer | undefined;
8385
+ /** The token counts a manual compaction's boundary names, when this stream event is that boundary. */
8386
+ declare function rcManualCompactBoundaryOf(event: RcStreamEvent): ReportOf<{
8387
+ kind: "compact";
8388
+ instructions: undefined;
8389
+ }> | undefined;
8390
+ /** Reads `/goal`'s answer with no argument, or undefined when the text is neither shape the verified versions answer with. */
8391
+ declare function parseRcGoalOutput(output: string): ReportOf<{
8392
+ kind: "goal-get";
8393
+ }> | undefined;
8394
+ /** The Claude Code version each observed session's worker reported, read off its own `system/init` events. */
8395
+ interface RcClaudeCodeVersions {
8396
+ readonly versionOf: (sessionId: string) => string | undefined;
8397
+ /** Drops the sessions `isTracked` no longer holds, so an ended session's version is not kept. */
8398
+ readonly sweep: (isTracked: (sessionId: string) => boolean) => void;
8399
+ }
8400
+ /** Subscribes to every session's stream and files the `claude_code_version` each worker-sourced `system/init` names, the worker's own statement of the version it runs (it emits one at the start of the stream and after every turn); an event a client wrote is never taken for the worker's. In memory: on the self-hosted surface a session lives exactly as long as the door that serves it. */
8401
+ declare function createRcClaudeCodeVersions(fanout: RcEventFanout): RcClaudeCodeVersions;
8402
+
8403
+ /**
8404
+ * Goal and compaction control over a Remote Control session: read, set and clear its `/goal`, and compact its conversation, each returning the outcome the session itself reports. One verb surface over the two routes Claude Code 2.1.319 leaves open, chosen per session:
8405
+ *
8406
+ * - **A supervised session** (one an agent-shim supervisor launched, whatever its account or provider): the door finds the launch through the registry, by the `bridge-session` row Claude Code writes into the session's own transcript, and asks the session's in-process control plugin (`supervise/sessionControlPlugin.ts`), which runs `$.session.compact` or `/goal <condition>` and `/goal clear` through the plugin API. The goal is read from the transcript's `goal_status` rows, with no effect on the session.
8407
+ * - **A session on the door's self-hosted surface** that no supervisor owns: the door is the Remote Control service there, so it writes the slash command into its own conversation as a person's app would and reads the worker's answer off the stream (`rcSelfHostCommands.ts`).
8408
+ *
8409
+ * Any other session is refused with the reason: the door has no in-process channel into it, and on the real service the worker runs a slash command only when a person's app wrote it (it treats every other writer, the door's own `send` among them, as a peer whose message the model reads as text), which the door will not claim to be.
8410
+ *
8411
+ * Both routes are verified for exactly the Claude Code versions `RC_SESSION_COMMAND_VERIFIED_VERSIONS` names, read from the running binary itself (the plugin's `$.session.version()`, or the worker's own `system/init`), and every verb refuses a session on any other version, or one whose version is not known.
8412
+ */
8413
+ /** The Claude Code versions both routes were verified on end to end; a session reporting any other version is refused. */
8414
+ declare const RC_SESSION_COMMAND_VERIFIED_VERSIONS: readonly string[];
8415
+ /** The arguments the 2.1.319 `/goal` command reads as a request to clear the goal rather than set one, compared case-insensitively; a condition that is one of these words cannot be set through `/goal`, so the set verb refuses it rather than clear the goal by accident. */
8416
+ declare const RC_GOAL_CLEAR_WORDS: readonly string[];
8417
+ /** The longest goal condition the 2.1.319 `/goal` command accepts, in characters; it refuses a longer one with its own message, so the set verb refuses it first, unsent. */
8418
+ declare const RC_GOAL_CONDITION_MAX_CHARS = 4000;
8419
+ /**
8420
+ * The longest any verb waits for the session's answer: the largest delay Node's timers accept (a signed 32-bit millisecond count), since a larger one fires after one millisecond instead. Every wait the verbs take is bounded by it, in the schema, the CLI's parser and the timer itself.
8421
+ */
8422
+ declare const RC_SESSION_COMMAND_MAX_WAIT_MS = 2147483647;
8423
+ /** Who answered: the session's supervisor through its in-process plugin, or the door's own self-hosted surface. */
8424
+ type RcSessionCommandRoute = "supervised" | "self-hosted";
8425
+ /** One goal as the session reports it. */
8426
+ type RcGoal = TranscriptGoal;
8427
+ /** What a goal read found: the active goal, or `null` when the session has none. */
8428
+ interface RcGoalReport {
8429
+ readonly route: RcSessionCommandRoute;
8430
+ readonly goal: RcGoal | null;
8431
+ }
8432
+ /** What a goal set did: the condition now set, and the one it replaced, or `null` when none was set. */
8433
+ interface RcGoalSetReport {
8434
+ readonly route: RcSessionCommandRoute;
8435
+ readonly condition: string;
8436
+ readonly superseded: string | null;
8437
+ }
8438
+ /** What a goal clear did: the condition it cleared, or `null` when the session had no goal to clear. */
8439
+ interface RcGoalClearReport {
8440
+ readonly route: RcSessionCommandRoute;
8441
+ readonly cleared: string | null;
8442
+ }
8443
+ /** What a completed compaction reported: what triggered it as the session names it, and the token counts before and after when the session recorded them. */
8444
+ interface RcCompactReport {
8445
+ readonly route: RcSessionCommandRoute;
8446
+ readonly trigger: string;
8447
+ readonly preTokens?: number;
8448
+ readonly postTokens?: number;
8449
+ }
8450
+ /** One verb's outcome: the report, or a verbose failure ready to show a user. */
8451
+ type RcSessionCommandResult<T> = {
8452
+ readonly ok: true;
8453
+ readonly report: T;
8454
+ } | {
8455
+ readonly ok: false;
8456
+ readonly message: string;
8457
+ };
8458
+ /** The options every verb takes. */
8459
+ interface RcSessionCommandOptions {
8460
+ /** How long to wait for the session's answer, in milliseconds, at most `RC_SESSION_COMMAND_MAX_WAIT_MS`; the supervisor's own bound on one compaction (`COMPACT_TIMEOUT_MS`) when absent, since a compaction's one summary request is the longest thing a verb waits on and a goal command, which makes no model request, is answered well within it. */
8461
+ readonly waitMs?: number;
8462
+ /** Aborts the wait, as the caller's request ending does. */
8463
+ readonly signal?: AbortSignal;
8464
+ }
8465
+ /** A compaction's options beyond the wait. */
8466
+ interface RcCompactOptions extends RcSessionCommandOptions {
8467
+ /** Custom summarisation instructions. A directive to the session's model, which is why the typed API serves it under its own grant. */
8468
+ readonly instructions?: string;
8469
+ }
8470
+ /** The supervised launch a Remote Control session belongs to, as the door reaches it. */
8471
+ interface RcSupervisedTarget {
8472
+ /** The conversation the plugin acts on: the session's current one, which differs from its launch id after `/clear`. */
8473
+ readonly conversationId: string;
8474
+ /** The session's current transcript, the goal's record; undefined until the session's hooks have named it. */
8475
+ readonly transcriptPath: string | undefined;
8476
+ /** The Claude Code version the plugin reported when it loaded; undefined when it has not loaded. */
8477
+ readonly version: string | undefined;
8478
+ /** Compacts through the plugin; the request is runnable for `waitMs` and no longer. */
8479
+ readonly compact: (signal: AbortSignal, instructions: string | undefined, waitMs: number) => Promise<CompactionResult>;
8480
+ /** Runs `/goal <args>` through the plugin, runnable for `waitMs` and no longer. */
8481
+ readonly runGoal: (args: string, signal: AbortSignal, waitMs: number) => Promise<unknown>;
8482
+ }
8483
+ /** Everything the verbs need, injected so they run against fakes in unit tests. */
8484
+ interface RcSessionCommandDeps {
8485
+ /** The supervised launch a `cse_` session belongs to; undefined when no live supervisor owns it, or when it does but its control plugin is not recorded; a refusal when the door cannot tell which launch it is (two live launches claim it). */
8486
+ readonly supervisedOf: (sessionId: string) => Promise<RcSupervisedTarget | {
8487
+ readonly refused: string;
8488
+ } | undefined>;
8489
+ /** The goal a transcript leaves active, read incrementally without blocking (`transcriptFollower.ts`); undefined when the file does not exist. */
8490
+ readonly goalOf: (path: string) => Promise<RcGoal | null | undefined>;
8491
+ /** The door's own surface, present only when the door serves Remote Control itself: the one place it writes a command as a person's app. */
8492
+ readonly selfHost: RcSelfHostCommandDeps | undefined;
8493
+ /** Whether the door observes the session at all, so a mistyped id is refused as unknown rather than as unsupported. */
8494
+ readonly isObserved: (sessionId: string) => boolean;
8495
+ }
8496
+ /** Creates the verbs over their dependencies. Verbs on one session run one at a time, in the order they were asked, so two commands never interleave on one session and one never reads the other's answer. */
8497
+ declare function createRcSessionCommands(deps: RcSessionCommandDeps): {
8498
+ /** Reads the session's goal: from the transcript for a supervised session, with no effect on it; by running `/goal` on the self-hosted surface otherwise. */
8499
+ goalGet: (sessionId: string, options?: RcSessionCommandOptions) => Promise<RcSessionCommandResult<RcGoalReport>>;
8500
+ /**
8501
+ * Sets the session's goal: the goal check then keeps the session working until the condition holds, and the condition reaches its model as a directive (`docs/rc-slash-commands.md`, the trust boundary). Refused unsent: an empty condition, one `/goal` reads as a clear, and one longer than it accepts. The answer names the goal it replaced.
8502
+ */
8503
+ goalSet: (sessionId: string, condition: string, options?: RcSessionCommandOptions) => Promise<RcSessionCommandResult<RcGoalSetReport>>;
8504
+ /** Clears the session's goal and names the condition it cleared, or `null` when there was none, which is not a failure (clearing is idempotent). */
8505
+ goalClear: (sessionId: string, options?: RcSessionCommandOptions) => Promise<RcSessionCommandResult<RcGoalClearReport>>;
8506
+ /** Compacts the session's conversation, with custom summary instructions when given, and resolves with the outcome: the trigger and token counts, or the session's reason for not compacting. */
8507
+ compact: (sessionId: string, options?: RcCompactOptions) => Promise<RcSessionCommandResult<RcCompactReport>>;
8508
+ };
8509
+ /** The verbs as `createRcSessionCommands` builds them. */
8510
+ type RcSessionCommands = ReturnType<typeof createRcSessionCommands>;
8511
+
8096
8512
  /**
8097
8513
  * A secondary pre-pipeline surface the listener answers under one path prefix: the typed Remote Control API. The listener owns only the dispatch (the prefix and the not-matched 404); the handle itself is whatever the door built, so this file stays independent of the API framework behind it.
8098
8514
  */
@@ -8158,6 +8574,14 @@ interface RcApiDeps {
8158
8574
  readonly mcpOAuthCallbackUrl: (sessionId: string, serverName: string, callbackUrl: string) => Promise<RcEventWriteResult>;
8159
8575
  /** The teleport operation, already wired to the tracker and the door's API-host dial. */
8160
8576
  readonly teleport: (sessionId: string, marker: string) => Promise<RcEventWriteResult>;
8577
+ /** The goal read (`rcSessionCommands.ts`), routed to the session's supervisor or the door's own self-hosted surface. */
8578
+ readonly goalGet: (sessionId: string, options: RcSessionCommandOptions) => Promise<RcSessionCommandResult<RcGoalReport>>;
8579
+ /** The goal set, routed the same way. */
8580
+ readonly goalSet: (sessionId: string, condition: string, options: RcSessionCommandOptions) => Promise<RcSessionCommandResult<RcGoalSetReport>>;
8581
+ /** The goal clear, routed the same way. */
8582
+ readonly goalClear: (sessionId: string, options: RcSessionCommandOptions) => Promise<RcSessionCommandResult<RcGoalClearReport>>;
8583
+ /** The compaction, routed the same way. */
8584
+ readonly compact: (sessionId: string, options: RcCompactOptions) => Promise<RcSessionCommandResult<RcCompactReport>>;
8161
8585
  /** The client attachment's fan-out, whose events the subscription yields. */
8162
8586
  readonly fanout: RcEventFanout;
8163
8587
  }
@@ -8196,6 +8620,17 @@ declare function createRcApiRouter(deps: RcApiDeps): {
8196
8620
  requestId: zod.ZodString;
8197
8621
  type: zod.ZodString;
8198
8622
  summary: zod.ZodString;
8623
+ questions: zod.ZodOptional<zod.ZodReadonly<zod.ZodArray<zod.ZodObject<{
8624
+ question: zod.ZodString;
8625
+ header: zod.ZodOptional<zod.ZodString>;
8626
+ multiSelect: zod.ZodBoolean;
8627
+ options: zod.ZodReadonly<zod.ZodArray<zod.ZodObject<{
8628
+ label: zod.ZodString;
8629
+ description: zod.ZodOptional<zod.ZodString>;
8630
+ }, zod_v4_core.$strict>>>;
8631
+ }, zod_v4_core.$strict>>>>;
8632
+ oversized: zod.ZodOptional<zod.ZodLiteral<true>>;
8633
+ unanswerable: zod.ZodOptional<zod.ZodString>;
8199
8634
  observedAt: zod.ZodNumber;
8200
8635
  }, zod_v4_core.$strict>>>;
8201
8636
  identity: zod.ZodOptional<zod.ZodString>;
@@ -8203,6 +8638,7 @@ declare function createRcApiRouter(deps: RcApiDeps): {
8203
8638
  name: zod.ZodOptional<zod.ZodString>;
8204
8639
  pid: zod.ZodOptional<zod.ZodNumber>;
8205
8640
  cwd: zod.ZodOptional<zod.ZodString>;
8641
+ pendingDropped: zod.ZodOptional<zod.ZodInt>;
8206
8642
  id: zod.ZodString;
8207
8643
  createdAt: zod.ZodNumber;
8208
8644
  lastSeenAt: zod.ZodNumber;
@@ -8216,8 +8652,23 @@ declare function createRcApiRouter(deps: RcApiDeps): {
8216
8652
  requestId: zod.ZodString;
8217
8653
  type: zod.ZodString;
8218
8654
  summary: zod.ZodString;
8655
+ questions: zod.ZodOptional<zod.ZodReadonly<zod.ZodArray<zod.ZodObject<{
8656
+ question: zod.ZodString;
8657
+ header: zod.ZodOptional<zod.ZodString>;
8658
+ multiSelect: zod.ZodBoolean;
8659
+ options: zod.ZodReadonly<zod.ZodArray<zod.ZodObject<{
8660
+ label: zod.ZodString;
8661
+ description: zod.ZodOptional<zod.ZodString>;
8662
+ }, zod_v4_core.$strict>>>;
8663
+ }, zod_v4_core.$strict>>>>;
8664
+ oversized: zod.ZodOptional<zod.ZodLiteral<true>>;
8665
+ unanswerable: zod.ZodOptional<zod.ZodString>;
8219
8666
  observedAt: zod.ZodNumber;
8220
8667
  }, zod_v4_core.$strict>>>;
8668
+ dropped: zod.ZodOptional<zod.ZodReadonly<zod.ZodArray<zod.ZodObject<{
8669
+ sessionId: zod.ZodString;
8670
+ count: zod.ZodInt;
8671
+ }, zod_v4_core.$strict>>>>;
8221
8672
  }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
8222
8673
  send: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
8223
8674
  session: zod.ZodString;
@@ -8231,6 +8682,9 @@ declare function createRcApiRouter(deps: RcApiDeps): {
8231
8682
  request: zod.ZodString;
8232
8683
  approve: zod.ZodBoolean;
8233
8684
  text: zod.ZodOptional<zod.ZodString>;
8685
+ choices: zod.ZodOptional<zod.ZodArray<zod.ZodArray<zod.ZodUnion<readonly [zod.ZodString, zod.ZodInt, zod.ZodObject<{
8686
+ text: zod.ZodString;
8687
+ }, zod_v4_core.$strict>]>>>>;
8234
8688
  }, zod_v4_core.$strict>, zod.ZodObject<{
8235
8689
  session: zod.ZodString;
8236
8690
  request: zod.ZodString;
@@ -8355,10 +8809,76 @@ declare function createRcApiRouter(deps: RcApiDeps): {
8355
8809
  }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
8356
8810
  teleport: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
8357
8811
  session: zod.ZodString;
8358
- marker: zod.ZodString;
8812
+ marker: zod.ZodString;
8813
+ }, zod_v4_core.$strict>, zod.ZodObject<{
8814
+ session: zod.ZodString;
8815
+ sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
8816
+ }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
8817
+ goalGet: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
8818
+ session: zod.ZodString;
8819
+ waitMs: zod.ZodOptional<zod.ZodInt>;
8820
+ }, zod_v4_core.$strict>, zod.ZodObject<{
8821
+ goal: zod.ZodNullable<zod.ZodObject<{
8822
+ condition: zod.ZodString;
8823
+ iterations: zod.ZodInt;
8824
+ lastCheck: zod.ZodOptional<zod.ZodString>;
8825
+ }, zod_v4_core.$strict>>;
8826
+ session: zod.ZodString;
8827
+ route: zod.ZodEnum<{
8828
+ supervised: "supervised";
8829
+ "self-hosted": "self-hosted";
8830
+ }>;
8831
+ }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
8832
+ goalSet: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
8833
+ session: zod.ZodString;
8834
+ condition: zod.ZodString;
8835
+ waitMs: zod.ZodOptional<zod.ZodInt>;
8836
+ }, zod_v4_core.$strict>, zod.ZodObject<{
8837
+ condition: zod.ZodString;
8838
+ superseded: zod.ZodNullable<zod.ZodString>;
8839
+ session: zod.ZodString;
8840
+ route: zod.ZodEnum<{
8841
+ supervised: "supervised";
8842
+ "self-hosted": "self-hosted";
8843
+ }>;
8844
+ }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
8845
+ goalClear: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
8846
+ session: zod.ZodString;
8847
+ waitMs: zod.ZodOptional<zod.ZodInt>;
8848
+ }, zod_v4_core.$strict>, zod.ZodObject<{
8849
+ cleared: zod.ZodNullable<zod.ZodString>;
8850
+ session: zod.ZodString;
8851
+ route: zod.ZodEnum<{
8852
+ supervised: "supervised";
8853
+ "self-hosted": "self-hosted";
8854
+ }>;
8855
+ }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
8856
+ compact: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
8857
+ session: zod.ZodString;
8858
+ waitMs: zod.ZodOptional<zod.ZodInt>;
8859
+ }, zod_v4_core.$strict>, zod.ZodObject<{
8860
+ trigger: zod.ZodString;
8861
+ preTokens: zod.ZodOptional<zod.ZodNumber>;
8862
+ postTokens: zod.ZodOptional<zod.ZodNumber>;
8863
+ session: zod.ZodString;
8864
+ route: zod.ZodEnum<{
8865
+ supervised: "supervised";
8866
+ "self-hosted": "self-hosted";
8867
+ }>;
8868
+ }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
8869
+ compactWithInstructions: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
8870
+ session: zod.ZodString;
8871
+ instructions: zod.ZodString;
8872
+ waitMs: zod.ZodOptional<zod.ZodInt>;
8359
8873
  }, zod_v4_core.$strict>, zod.ZodObject<{
8874
+ trigger: zod.ZodString;
8875
+ preTokens: zod.ZodOptional<zod.ZodNumber>;
8876
+ postTokens: zod.ZodOptional<zod.ZodNumber>;
8360
8877
  session: zod.ZodString;
8361
- sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
8878
+ route: zod.ZodEnum<{
8879
+ supervised: "supervised";
8880
+ "self-hosted": "self-hosted";
8881
+ }>;
8362
8882
  }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
8363
8883
  subscribe: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
8364
8884
  session: zod.ZodOptional<zod.ZodString>;
@@ -8834,127 +9354,6 @@ declare const CheckReportJsonSchema: z.ZodObject<{
8834
9354
  }, z.core.$strict>;
8835
9355
  type CheckReportJson = z.output<typeof CheckReportJsonSchema>;
8836
9356
 
8837
- /** 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. */
8838
- declare const CachedCredentialSchema: z.ZodObject<{
8839
- token: z.ZodString;
8840
- fetchedAt: z.ZodNumber;
8841
- source: z.ZodUnion<readonly [z.ZodObject<{
8842
- env: z.ZodString;
8843
- }, z.core.$strict>, z.ZodObject<{
8844
- file: z.ZodString;
8845
- }, z.core.$strict>, z.ZodObject<{
8846
- interactive: z.ZodOptional<z.ZodBoolean>;
8847
- timeoutMs: z.ZodOptional<z.ZodInt>;
8848
- command: z.ZodTuple<[z.ZodString], z.ZodString>;
8849
- }, z.core.$strict>, z.ZodObject<{
8850
- interactive: z.ZodOptional<z.ZodBoolean>;
8851
- timeoutMs: z.ZodOptional<z.ZodInt>;
8852
- op: z.ZodString;
8853
- }, z.core.$strict>, z.ZodObject<{
8854
- interactive: z.ZodOptional<z.ZodBoolean>;
8855
- timeoutMs: z.ZodOptional<z.ZodInt>;
8856
- keychain: z.ZodObject<{
8857
- service: z.ZodString;
8858
- account: z.ZodOptional<z.ZodString>;
8859
- }, z.core.$strict>;
8860
- }, z.core.$strict>, z.ZodObject<{
8861
- literal: z.ZodString;
8862
- }, z.core.$strict>]>;
8863
- owner: z.ZodOptional<z.ZodString>;
8864
- }, z.core.$strict>;
8865
- type CachedCredential = z.infer<typeof CachedCredentialSchema>;
8866
- /**
8867
- * Where cached credentials live, injected so resolution and its tests need neither the Keychain nor a real directory. `owner` names what the credential belongs to (`identity work`, `provider z`) and is the entry's key; `store` picks the backing store. `read` returns undefined for a missing or unreadable entry, since an entry that cannot be used is the same as no entry.
8868
- */
8869
- interface CredentialCachePort {
8870
- readonly read: (store: CredentialCacheStore, owner: string) => CachedCredential | undefined;
8871
- readonly write: (store: CredentialCacheStore, owner: string, entry: CachedCredential) => void;
8872
- readonly remove: (store: CredentialCacheStore, owner: string) => void;
8873
- }
8874
- /**
8875
- * 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.
8876
- */
8877
- type CachedCredentialState = {
8878
- readonly store: CredentialCacheStore;
8879
- readonly status: "empty";
8880
- }
8881
- /** 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. */
8882
- | {
8883
- readonly store: CredentialCacheStore;
8884
- readonly status: "unreadable";
8885
- readonly reason: string;
8886
- } | {
8887
- readonly store: CredentialCacheStore;
8888
- readonly status: "fresh" | "expired";
8889
- readonly ageMs: number;
8890
- readonly expiresInMs?: number;
8891
- };
8892
-
8893
- /** 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. */
8894
- type SecretFileRead = {
8895
- readonly found: false;
8896
- } | {
8897
- readonly found: true;
8898
- readonly content: string;
8899
- readonly mode: number | undefined;
8900
- };
8901
- /** The outcome of one credential command. `stderr` is empty for an interactive run, whose stderr goes to the terminal so a person sees any prompt. */
8902
- interface CredentialCommandResult {
8903
- readonly status: number | null;
8904
- readonly stdout: string;
8905
- readonly stderr: string;
8906
- readonly timedOut: boolean;
8907
- }
8908
- /**
8909
- * Everything resolving a credential needs from the outside world, injected so the resolver (and every launcher test) runs without `op`, the Keychain, real secret files or a terminal. `src/realPorts.ts` wires the real one; tests wire a fake.
8910
- */
8911
- interface CredentialPort {
8912
- /** Reads a `file` source's path (absolute or `~`-rooted). */
8913
- readonly readSecretFile: (filePath: string) => SecretFileRead;
8914
- /** Runs a command source's argv directly (no shell) under a timeout, capturing stdout. An interactive run inherits the terminal's stdin and stderr so a person can answer a prompt. */
8915
- readonly runCommand: (argv: readonly [string, ...string[]], options: {
8916
- readonly timeoutMs: number;
8917
- readonly interactive: boolean;
8918
- }) => CredentialCommandResult;
8919
- /** Whether a person can answer a prompt now: standard input is a terminal, or there is a desktop session to show a dialog in. */
8920
- readonly personPresent: () => boolean;
8921
- /** Where cached credentials live, used only for a credential block that asks for caching. Omit to resolve every launch from the sources. */
8922
- readonly cache?: CredentialCacheEnv;
8923
- }
8924
- /** One source as `check`, `doctor` and every `--json` output report it: its kind plus the same non-secret identifying detail `describeSource` prints. */
8925
- type CredentialSourceSummary = {
8926
- readonly kind: "env";
8927
- readonly variable: string;
8928
- } | {
8929
- readonly kind: "file";
8930
- readonly path: string;
8931
- } | {
8932
- readonly kind: "command";
8933
- readonly program: string;
8934
- } | {
8935
- readonly kind: "op";
8936
- readonly reference: string;
8937
- } | {
8938
- readonly kind: "keychain";
8939
- readonly service: string;
8940
- readonly account?: string;
8941
- } | {
8942
- readonly kind: "literal";
8943
- };
8944
- /** A credential block as it is reported: its effective target and each source's summary, in order. */
8945
- interface CredentialSummary {
8946
- readonly target: CredentialTarget;
8947
- readonly sources: readonly CredentialSourceSummary[];
8948
- /** The block's cache setting when it asks for caching: how long a token is kept (absent for no expiry) and where. Carried as the config schema's own type, since the summary passes the parsed block's setting through unchanged. */
8949
- readonly cache?: CredentialCache;
8950
- }
8951
- /** What caching a credential needs beyond the block's own `cache` setting: the port holding entries, the platform that picks the default store, and the clock the TTL is measured on. */
8952
- interface CredentialCacheEnv {
8953
- readonly port: CredentialCachePort;
8954
- readonly platform: NodeJS.Platform;
8955
- readonly now: () => number;
8956
- }
8957
-
8958
9357
  /** Where a pinned Claude Code version came from, strongest first: the launch's own flag, then the environment, then the cascade. */
8959
9358
  declare const CLAUDE_VERSION_SOURCES: readonly ["flag", "environment", "cascade"];
8960
9359
  type ClaudeVersionSource = (typeof CLAUDE_VERSION_SOURCES)[number];
@@ -9830,22 +10229,6 @@ interface RenameJournalListing {
9830
10229
  declare const ProviderAliasesSchema: z.ZodRecord<z.ZodString, z.ZodString>;
9831
10230
  type ProviderAliases = z.infer<typeof ProviderAliasesSchema>;
9832
10231
 
9833
- /** The result of a successful discovery. */
9834
- interface DiscoveredClaudeBinary {
9835
- /** Full path to the discovered `claude` executable. */
9836
- path: string;
9837
- /** Which strategy found it. */
9838
- source: "versions-dir" | "path-fallback";
9839
- /** The version string, when discovered via the versions directory. */
9840
- version?: string;
9841
- }
9842
- /** What a launch asks binary discovery for: nothing (the highest installed version) or an exact version. */
9843
- interface ClaudeBinaryRequest {
9844
- readonly version?: string;
9845
- }
9846
- /** Discovers the real `claude` binary to spawn, for the version a launch asked for. Injected into the launcher so it never reads the filesystem or PATH itself. */
9847
- type ClaudeBinaryResolver = (request?: Readonly<ClaudeBinaryRequest>) => DiscoveredClaudeBinary;
9848
-
9849
10232
  declare const DOCTOR_SEVERITIES: readonly ["pass", "warn", "fail"];
9850
10233
  type DoctorSeverity = (typeof DOCTOR_SEVERITIES)[number];
9851
10234
  declare const DOCTOR_SECTIONS: readonly ["ambient-credential", "binary-discovery", "claude-shim", "path-resolution", "legacy-name", "config-profile", "identity", "sign-in", "pool", "provider", "keychain", "directory-rules", "global-config", "categories-local", "active-identity", "headroom", "frontdoor", "models"];
@@ -10088,15 +10471,6 @@ type CodexApiRouter = ReturnType<typeof createCodexApiRouter>;
10088
10471
  /** The Codex procedures alone as a client sees them. */
10089
10472
  type CodexApiClient = RouterClient<CodexApiRouter>;
10090
10473
 
10091
- /** The outcome of one external command, as `RunPort` reports it. */
10092
- interface ReplayRunResult {
10093
- readonly status: number | null;
10094
- readonly stdout: string;
10095
- readonly stderr: string;
10096
- }
10097
- /** Runs an external command without blocking the calling thread. */
10098
- type AsyncRun = (command: string, args: readonly string[]) => Promise<ReplayRunResult>;
10099
-
10100
10474
  /**
10101
10475
  * The door's configuration management as a typed oRPC API: the writes the CLI's `identity`, `profile`, `pool`, `provider` and `rule` verbs make, as `config.<noun>.<verb>` procedures, every one behind the same per-generation control token as the rest of the mount.
10102
10476
  *
@@ -10482,12 +10856,12 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
10482
10856
  header: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
10483
10857
  identity: "identity";
10484
10858
  model: "model";
10859
+ route: "route";
10485
10860
  account: "account";
10486
10861
  provider: "provider";
10487
10862
  version: "version";
10488
10863
  headroom: "headroom";
10489
10864
  duration: "duration";
10490
- route: "route";
10491
10865
  project: "project";
10492
10866
  vcs: "vcs";
10493
10867
  effort: "effort";
@@ -10983,8 +11357,8 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
10983
11357
  project: zod.ZodOptional<zod.ZodObject<{
10984
11358
  pathLevels: zod.ZodOptional<zod.ZodEnum<{
10985
11359
  full: "full";
10986
- 1: "1";
10987
11360
  2: "2";
11361
+ 1: "1";
10988
11362
  3: "3";
10989
11363
  }>>;
10990
11364
  addedDirsLayout: zod.ZodOptional<zod.ZodEnum<{
@@ -11206,12 +11580,12 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
11206
11580
  header: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
11207
11581
  identity: "identity";
11208
11582
  model: "model";
11583
+ route: "route";
11209
11584
  account: "account";
11210
11585
  provider: "provider";
11211
11586
  version: "version";
11212
11587
  headroom: "headroom";
11213
11588
  duration: "duration";
11214
- route: "route";
11215
11589
  project: "project";
11216
11590
  vcs: "vcs";
11217
11591
  effort: "effort";
@@ -11707,8 +12081,8 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
11707
12081
  project: zod.ZodOptional<zod.ZodObject<{
11708
12082
  pathLevels: zod.ZodOptional<zod.ZodEnum<{
11709
12083
  full: "full";
11710
- 1: "1";
11711
12084
  2: "2";
12085
+ 1: "1";
11712
12086
  3: "3";
11713
12087
  }>>;
11714
12088
  addedDirsLayout: zod.ZodOptional<zod.ZodEnum<{
@@ -12406,12 +12780,12 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
12406
12780
  header: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
12407
12781
  identity: "identity";
12408
12782
  model: "model";
12783
+ route: "route";
12409
12784
  account: "account";
12410
12785
  provider: "provider";
12411
12786
  version: "version";
12412
12787
  headroom: "headroom";
12413
12788
  duration: "duration";
12414
- route: "route";
12415
12789
  project: "project";
12416
12790
  vcs: "vcs";
12417
12791
  effort: "effort";
@@ -12907,8 +13281,8 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
12907
13281
  project: zod.ZodOptional<zod.ZodObject<{
12908
13282
  pathLevels: zod.ZodOptional<zod.ZodEnum<{
12909
13283
  full: "full";
12910
- 1: "1";
12911
13284
  2: "2";
13285
+ 1: "1";
12912
13286
  3: "3";
12913
13287
  }>>;
12914
13288
  addedDirsLayout: zod.ZodOptional<zod.ZodEnum<{
@@ -13187,12 +13561,12 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
13187
13561
  header: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
13188
13562
  identity: "identity";
13189
13563
  model: "model";
13564
+ route: "route";
13190
13565
  account: "account";
13191
13566
  provider: "provider";
13192
13567
  version: "version";
13193
13568
  headroom: "headroom";
13194
13569
  duration: "duration";
13195
- route: "route";
13196
13570
  project: "project";
13197
13571
  vcs: "vcs";
13198
13572
  effort: "effort";
@@ -13688,8 +14062,8 @@ declare function createConfigApiRouter(deps: ConfigApiDeps): {
13688
14062
  project: zod.ZodOptional<zod.ZodObject<{
13689
14063
  pathLevels: zod.ZodOptional<zod.ZodEnum<{
13690
14064
  full: "full";
13691
- 1: "1";
13692
14065
  2: "2";
14066
+ 1: "1";
13693
14067
  3: "3";
13694
14068
  }>>;
13695
14069
  addedDirsLayout: zod.ZodOptional<zod.ZodEnum<{
@@ -14160,12 +14534,12 @@ declare const StatuslineSchema: z.ZodObject<{
14160
14534
  header: z.ZodOptional<z.ZodArray<z.ZodEnum<{
14161
14535
  identity: "identity";
14162
14536
  model: "model";
14537
+ route: "route";
14163
14538
  account: "account";
14164
14539
  provider: "provider";
14165
14540
  version: "version";
14166
14541
  headroom: "headroom";
14167
14542
  duration: "duration";
14168
- route: "route";
14169
14543
  project: "project";
14170
14544
  vcs: "vcs";
14171
14545
  effort: "effort";
@@ -14661,8 +15035,8 @@ declare const StatuslineSchema: z.ZodObject<{
14661
15035
  project: z.ZodOptional<z.ZodObject<{
14662
15036
  pathLevels: z.ZodOptional<z.ZodEnum<{
14663
15037
  full: "full";
14664
- 1: "1";
14665
15038
  2: "2";
15039
+ 1: "1";
14666
15040
  3: "3";
14667
15041
  }>>;
14668
15042
  addedDirsLayout: z.ZodOptional<z.ZodEnum<{
@@ -14730,18 +15104,6 @@ interface SupervisedLaunch {
14730
15104
  readonly settingsFile?: string;
14731
15105
  }
14732
15106
 
14733
- /** The effects a hold needs, so it runs against fakes in tests. */
14734
- interface HoldPort {
14735
- /** Whether a person is watching: standard input and standard output are both terminals. A launch nobody watches is never held. */
14736
- readonly attended: () => boolean;
14737
- /** Blocks for `ms` milliseconds. */
14738
- readonly sleep: (ms: number) => void;
14739
- /** Blocks until one key is pressed, and says whether it was the interrupt key (Ctrl-C), which a terminal in the mode this reads in delivers as a byte and not as a signal. */
14740
- readonly waitForKey: () => "key" | "interrupt";
14741
- }
14742
- /** What a hold decided: carry on with the launch, or the person cancelled it. */
14743
- type HoldOutcome = "go" | "cancelled";
14744
-
14745
15107
  /**
14746
15108
  * Everything the launch-time update check needs from its host, injected so tests run it against scripted answers and no launch ever reaches GitHub by accident. Deliberately narrower than `UpdatePorts`: the launch path never downloads anything (the detached `agent-shim update` does), so only the release check, the cooldown stamp, the clock, the background spawn and the terminal are wired.
14747
15109
  */
@@ -15028,12 +15390,12 @@ declare function createLaunchApiRouter(deps: LaunchApiDeps): {
15028
15390
  header: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
15029
15391
  identity: "identity";
15030
15392
  model: "model";
15393
+ route: "route";
15031
15394
  account: "account";
15032
15395
  provider: "provider";
15033
15396
  version: "version";
15034
15397
  headroom: "headroom";
15035
15398
  duration: "duration";
15036
- route: "route";
15037
15399
  project: "project";
15038
15400
  vcs: "vcs";
15039
15401
  effort: "effort";
@@ -15529,8 +15891,8 @@ declare function createLaunchApiRouter(deps: LaunchApiDeps): {
15529
15891
  project: zod.ZodOptional<zod.ZodObject<{
15530
15892
  pathLevels: zod.ZodOptional<zod.ZodEnum<{
15531
15893
  full: "full";
15532
- 1: "1";
15533
15894
  2: "2";
15895
+ 1: "1";
15534
15896
  3: "3";
15535
15897
  }>>;
15536
15898
  addedDirsLayout: zod.ZodOptional<zod.ZodEnum<{
@@ -15859,9 +16221,10 @@ declare function createRcSessionEventsApiRouter(deps: RcSessionEventsApiDeps): {
15859
16221
  kind: zod.ZodLiteral<"pending-retired">;
15860
16222
  requestId: zod.ZodString;
15861
16223
  reason: zod.ZodEnum<{
15862
- expired: "expired";
15863
16224
  "session-ended": "session-ended";
15864
16225
  answered: "answered";
16226
+ withdrawn: "withdrawn";
16227
+ "worker-stopped": "worker-stopped";
15865
16228
  }>;
15866
16229
  cursor: zod.ZodString;
15867
16230
  sequence: zod.ZodInt;
@@ -16754,12 +17117,12 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
16754
17117
  header: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
16755
17118
  identity: "identity";
16756
17119
  model: "model";
17120
+ route: "route";
16757
17121
  account: "account";
16758
17122
  provider: "provider";
16759
17123
  version: "version";
16760
17124
  headroom: "headroom";
16761
17125
  duration: "duration";
16762
- route: "route";
16763
17126
  project: "project";
16764
17127
  vcs: "vcs";
16765
17128
  effort: "effort";
@@ -17255,8 +17618,8 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
17255
17618
  project: zod.ZodOptional<zod.ZodObject<{
17256
17619
  pathLevels: zod.ZodOptional<zod.ZodEnum<{
17257
17620
  full: "full";
17258
- 1: "1";
17259
17621
  2: "2";
17622
+ 1: "1";
17260
17623
  3: "3";
17261
17624
  }>>;
17262
17625
  addedDirsLayout: zod.ZodOptional<zod.ZodEnum<{
@@ -17725,12 +18088,12 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
17725
18088
  header: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
17726
18089
  identity: "identity";
17727
18090
  model: "model";
18091
+ route: "route";
17728
18092
  account: "account";
17729
18093
  provider: "provider";
17730
18094
  version: "version";
17731
18095
  headroom: "headroom";
17732
18096
  duration: "duration";
17733
- route: "route";
17734
18097
  project: "project";
17735
18098
  vcs: "vcs";
17736
18099
  effort: "effort";
@@ -18226,8 +18589,8 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
18226
18589
  project: zod.ZodOptional<zod.ZodObject<{
18227
18590
  pathLevels: zod.ZodOptional<zod.ZodEnum<{
18228
18591
  full: "full";
18229
- 1: "1";
18230
18592
  2: "2";
18593
+ 1: "1";
18231
18594
  3: "3";
18232
18595
  }>>;
18233
18596
  addedDirsLayout: zod.ZodOptional<zod.ZodEnum<{
@@ -18449,12 +18812,12 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
18449
18812
  header: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
18450
18813
  identity: "identity";
18451
18814
  model: "model";
18815
+ route: "route";
18452
18816
  account: "account";
18453
18817
  provider: "provider";
18454
18818
  version: "version";
18455
18819
  headroom: "headroom";
18456
18820
  duration: "duration";
18457
- route: "route";
18458
18821
  project: "project";
18459
18822
  vcs: "vcs";
18460
18823
  effort: "effort";
@@ -18950,8 +19313,8 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
18950
19313
  project: zod.ZodOptional<zod.ZodObject<{
18951
19314
  pathLevels: zod.ZodOptional<zod.ZodEnum<{
18952
19315
  full: "full";
18953
- 1: "1";
18954
19316
  2: "2";
19317
+ 1: "1";
18955
19318
  3: "3";
18956
19319
  }>>;
18957
19320
  addedDirsLayout: zod.ZodOptional<zod.ZodEnum<{
@@ -19649,12 +20012,12 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
19649
20012
  header: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
19650
20013
  identity: "identity";
19651
20014
  model: "model";
20015
+ route: "route";
19652
20016
  account: "account";
19653
20017
  provider: "provider";
19654
20018
  version: "version";
19655
20019
  headroom: "headroom";
19656
20020
  duration: "duration";
19657
- route: "route";
19658
20021
  project: "project";
19659
20022
  vcs: "vcs";
19660
20023
  effort: "effort";
@@ -20150,8 +20513,8 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
20150
20513
  project: zod.ZodOptional<zod.ZodObject<{
20151
20514
  pathLevels: zod.ZodOptional<zod.ZodEnum<{
20152
20515
  full: "full";
20153
- 1: "1";
20154
20516
  2: "2";
20517
+ 1: "1";
20155
20518
  3: "3";
20156
20519
  }>>;
20157
20520
  addedDirsLayout: zod.ZodOptional<zod.ZodEnum<{
@@ -20430,12 +20793,12 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
20430
20793
  header: zod.ZodOptional<zod.ZodArray<zod.ZodEnum<{
20431
20794
  identity: "identity";
20432
20795
  model: "model";
20796
+ route: "route";
20433
20797
  account: "account";
20434
20798
  provider: "provider";
20435
20799
  version: "version";
20436
20800
  headroom: "headroom";
20437
20801
  duration: "duration";
20438
- route: "route";
20439
20802
  project: "project";
20440
20803
  vcs: "vcs";
20441
20804
  effort: "effort";
@@ -20931,8 +21294,8 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
20931
21294
  project: zod.ZodOptional<zod.ZodObject<{
20932
21295
  pathLevels: zod.ZodOptional<zod.ZodEnum<{
20933
21296
  full: "full";
20934
- 1: "1";
20935
21297
  2: "2";
21298
+ 1: "1";
20936
21299
  3: "3";
20937
21300
  }>>;
20938
21301
  addedDirsLayout: zod.ZodOptional<zod.ZodEnum<{
@@ -21685,9 +22048,10 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
21685
22048
  kind: zod.ZodLiteral<"pending-retired">;
21686
22049
  requestId: zod.ZodString;
21687
22050
  reason: zod.ZodEnum<{
21688
- expired: "expired";
21689
22051
  "session-ended": "session-ended";
21690
22052
  answered: "answered";
22053
+ withdrawn: "withdrawn";
22054
+ "worker-stopped": "worker-stopped";
21691
22055
  }>;
21692
22056
  cursor: zod.ZodString;
21693
22057
  sequence: zod.ZodInt;
@@ -21726,6 +22090,17 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
21726
22090
  requestId: zod.ZodString;
21727
22091
  type: zod.ZodString;
21728
22092
  summary: zod.ZodString;
22093
+ questions: zod.ZodOptional<zod.ZodReadonly<zod.ZodArray<zod.ZodObject<{
22094
+ question: zod.ZodString;
22095
+ header: zod.ZodOptional<zod.ZodString>;
22096
+ multiSelect: zod.ZodBoolean;
22097
+ options: zod.ZodReadonly<zod.ZodArray<zod.ZodObject<{
22098
+ label: zod.ZodString;
22099
+ description: zod.ZodOptional<zod.ZodString>;
22100
+ }, zod_v4_core.$strict>>>;
22101
+ }, zod_v4_core.$strict>>>>;
22102
+ oversized: zod.ZodOptional<zod.ZodLiteral<true>>;
22103
+ unanswerable: zod.ZodOptional<zod.ZodString>;
21729
22104
  observedAt: zod.ZodNumber;
21730
22105
  }, zod_v4_core.$strict>>>;
21731
22106
  identity: zod.ZodOptional<zod.ZodString>;
@@ -21733,6 +22108,7 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
21733
22108
  name: zod.ZodOptional<zod.ZodString>;
21734
22109
  pid: zod.ZodOptional<zod.ZodNumber>;
21735
22110
  cwd: zod.ZodOptional<zod.ZodString>;
22111
+ pendingDropped: zod.ZodOptional<zod.ZodInt>;
21736
22112
  id: zod.ZodString;
21737
22113
  createdAt: zod.ZodNumber;
21738
22114
  lastSeenAt: zod.ZodNumber;
@@ -21746,8 +22122,23 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
21746
22122
  requestId: zod.ZodString;
21747
22123
  type: zod.ZodString;
21748
22124
  summary: zod.ZodString;
22125
+ questions: zod.ZodOptional<zod.ZodReadonly<zod.ZodArray<zod.ZodObject<{
22126
+ question: zod.ZodString;
22127
+ header: zod.ZodOptional<zod.ZodString>;
22128
+ multiSelect: zod.ZodBoolean;
22129
+ options: zod.ZodReadonly<zod.ZodArray<zod.ZodObject<{
22130
+ label: zod.ZodString;
22131
+ description: zod.ZodOptional<zod.ZodString>;
22132
+ }, zod_v4_core.$strict>>>;
22133
+ }, zod_v4_core.$strict>>>>;
22134
+ oversized: zod.ZodOptional<zod.ZodLiteral<true>>;
22135
+ unanswerable: zod.ZodOptional<zod.ZodString>;
21749
22136
  observedAt: zod.ZodNumber;
21750
22137
  }, zod_v4_core.$strict>>>;
22138
+ dropped: zod.ZodOptional<zod.ZodReadonly<zod.ZodArray<zod.ZodObject<{
22139
+ sessionId: zod.ZodString;
22140
+ count: zod.ZodInt;
22141
+ }, zod_v4_core.$strict>>>>;
21751
22142
  }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
21752
22143
  send: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
21753
22144
  session: zod.ZodString;
@@ -21761,6 +22152,9 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
21761
22152
  request: zod.ZodString;
21762
22153
  approve: zod.ZodBoolean;
21763
22154
  text: zod.ZodOptional<zod.ZodString>;
22155
+ choices: zod.ZodOptional<zod.ZodArray<zod.ZodArray<zod.ZodUnion<readonly [zod.ZodString, zod.ZodInt, zod.ZodObject<{
22156
+ text: zod.ZodString;
22157
+ }, zod_v4_core.$strict>]>>>>;
21764
22158
  }, zod_v4_core.$strict>, zod.ZodObject<{
21765
22159
  session: zod.ZodString;
21766
22160
  request: zod.ZodString;
@@ -21890,6 +22284,72 @@ declare function createDoorApiRouter(deps: DoorApiDeps): {
21890
22284
  session: zod.ZodString;
21891
22285
  sequenceNums: zod.ZodReadonly<zod.ZodArray<zod.ZodNumber>>;
21892
22286
  }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
22287
+ goalGet: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
22288
+ session: zod.ZodString;
22289
+ waitMs: zod.ZodOptional<zod.ZodInt>;
22290
+ }, zod_v4_core.$strict>, zod.ZodObject<{
22291
+ goal: zod.ZodNullable<zod.ZodObject<{
22292
+ condition: zod.ZodString;
22293
+ iterations: zod.ZodInt;
22294
+ lastCheck: zod.ZodOptional<zod.ZodString>;
22295
+ }, zod_v4_core.$strict>>;
22296
+ session: zod.ZodString;
22297
+ route: zod.ZodEnum<{
22298
+ supervised: "supervised";
22299
+ "self-hosted": "self-hosted";
22300
+ }>;
22301
+ }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
22302
+ goalSet: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
22303
+ session: zod.ZodString;
22304
+ condition: zod.ZodString;
22305
+ waitMs: zod.ZodOptional<zod.ZodInt>;
22306
+ }, zod_v4_core.$strict>, zod.ZodObject<{
22307
+ condition: zod.ZodString;
22308
+ superseded: zod.ZodNullable<zod.ZodString>;
22309
+ session: zod.ZodString;
22310
+ route: zod.ZodEnum<{
22311
+ supervised: "supervised";
22312
+ "self-hosted": "self-hosted";
22313
+ }>;
22314
+ }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
22315
+ goalClear: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
22316
+ session: zod.ZodString;
22317
+ waitMs: zod.ZodOptional<zod.ZodInt>;
22318
+ }, zod_v4_core.$strict>, zod.ZodObject<{
22319
+ cleared: zod.ZodNullable<zod.ZodString>;
22320
+ session: zod.ZodString;
22321
+ route: zod.ZodEnum<{
22322
+ supervised: "supervised";
22323
+ "self-hosted": "self-hosted";
22324
+ }>;
22325
+ }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
22326
+ compact: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
22327
+ session: zod.ZodString;
22328
+ waitMs: zod.ZodOptional<zod.ZodInt>;
22329
+ }, zod_v4_core.$strict>, zod.ZodObject<{
22330
+ trigger: zod.ZodString;
22331
+ preTokens: zod.ZodOptional<zod.ZodNumber>;
22332
+ postTokens: zod.ZodOptional<zod.ZodNumber>;
22333
+ session: zod.ZodString;
22334
+ route: zod.ZodEnum<{
22335
+ supervised: "supervised";
22336
+ "self-hosted": "self-hosted";
22337
+ }>;
22338
+ }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
22339
+ compactWithInstructions: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
22340
+ session: zod.ZodString;
22341
+ instructions: zod.ZodString;
22342
+ waitMs: zod.ZodOptional<zod.ZodInt>;
22343
+ }, zod_v4_core.$strict>, zod.ZodObject<{
22344
+ trigger: zod.ZodString;
22345
+ preTokens: zod.ZodOptional<zod.ZodNumber>;
22346
+ postTokens: zod.ZodOptional<zod.ZodNumber>;
22347
+ session: zod.ZodString;
22348
+ route: zod.ZodEnum<{
22349
+ supervised: "supervised";
22350
+ "self-hosted": "self-hosted";
22351
+ }>;
22352
+ }, zod_v4_core.$strict>, MergedErrorMap<$ErrorMap, TErrorMap>>;
21893
22353
  subscribe: _orpc_server.DecoratedProcedure<DoorApiContext & object, IntersectPick<TInitialContext, $OutContext>, zod.ZodObject<{
21894
22354
  session: zod.ZodOptional<zod.ZodString>;
21895
22355
  }, zod_v4_core.$strict>, any, MergedErrorMap<$ErrorMap, TErrorMap>>;
@@ -22335,12 +22795,12 @@ declare const ConfigProfileAddOutputSchema: z.ZodObject<{
22335
22795
  header: z.ZodOptional<z.ZodArray<z.ZodEnum<{
22336
22796
  identity: "identity";
22337
22797
  model: "model";
22798
+ route: "route";
22338
22799
  account: "account";
22339
22800
  provider: "provider";
22340
22801
  version: "version";
22341
22802
  headroom: "headroom";
22342
22803
  duration: "duration";
22343
- route: "route";
22344
22804
  project: "project";
22345
22805
  vcs: "vcs";
22346
22806
  effort: "effort";
@@ -22836,8 +23296,8 @@ declare const ConfigProfileAddOutputSchema: z.ZodObject<{
22836
23296
  project: z.ZodOptional<z.ZodObject<{
22837
23297
  pathLevels: z.ZodOptional<z.ZodEnum<{
22838
23298
  full: "full";
22839
- 1: "1";
22840
23299
  2: "2";
23300
+ 1: "1";
22841
23301
  3: "3";
22842
23302
  }>>;
22843
23303
  addedDirsLayout: z.ZodOptional<z.ZodEnum<{
@@ -23061,12 +23521,12 @@ declare const ConfigProfileSetOutputSchema: z.ZodObject<{
23061
23521
  header: z.ZodOptional<z.ZodArray<z.ZodEnum<{
23062
23522
  identity: "identity";
23063
23523
  model: "model";
23524
+ route: "route";
23064
23525
  account: "account";
23065
23526
  provider: "provider";
23066
23527
  version: "version";
23067
23528
  headroom: "headroom";
23068
23529
  duration: "duration";
23069
- route: "route";
23070
23530
  project: "project";
23071
23531
  vcs: "vcs";
23072
23532
  effort: "effort";
@@ -23562,8 +24022,8 @@ declare const ConfigProfileSetOutputSchema: z.ZodObject<{
23562
24022
  project: z.ZodOptional<z.ZodObject<{
23563
24023
  pathLevels: z.ZodOptional<z.ZodEnum<{
23564
24024
  full: "full";
23565
- 1: "1";
23566
24025
  2: "2";
24026
+ 1: "1";
23567
24027
  3: "3";
23568
24028
  }>>;
23569
24029
  addedDirsLayout: z.ZodOptional<z.ZodEnum<{
@@ -24263,12 +24723,12 @@ declare const ConfigRuleAddOutputSchema: z.ZodObject<{
24263
24723
  header: z.ZodOptional<z.ZodArray<z.ZodEnum<{
24264
24724
  identity: "identity";
24265
24725
  model: "model";
24726
+ route: "route";
24266
24727
  account: "account";
24267
24728
  provider: "provider";
24268
24729
  version: "version";
24269
24730
  headroom: "headroom";
24270
24731
  duration: "duration";
24271
- route: "route";
24272
24732
  project: "project";
24273
24733
  vcs: "vcs";
24274
24734
  effort: "effort";
@@ -24764,8 +25224,8 @@ declare const ConfigRuleAddOutputSchema: z.ZodObject<{
24764
25224
  project: z.ZodOptional<z.ZodObject<{
24765
25225
  pathLevels: z.ZodOptional<z.ZodEnum<{
24766
25226
  full: "full";
24767
- 1: "1";
24768
25227
  2: "2";
25228
+ 1: "1";
24769
25229
  3: "3";
24770
25230
  }>>;
24771
25231
  addedDirsLayout: z.ZodOptional<z.ZodEnum<{
@@ -25046,12 +25506,12 @@ declare const ConfigRuleSetOutputSchema: z.ZodObject<{
25046
25506
  header: z.ZodOptional<z.ZodArray<z.ZodEnum<{
25047
25507
  identity: "identity";
25048
25508
  model: "model";
25509
+ route: "route";
25049
25510
  account: "account";
25050
25511
  provider: "provider";
25051
25512
  version: "version";
25052
25513
  headroom: "headroom";
25053
25514
  duration: "duration";
25054
- route: "route";
25055
25515
  project: "project";
25056
25516
  vcs: "vcs";
25057
25517
  effort: "effort";
@@ -25547,8 +26007,8 @@ declare const ConfigRuleSetOutputSchema: z.ZodObject<{
25547
26007
  project: z.ZodOptional<z.ZodObject<{
25548
26008
  pathLevels: z.ZodOptional<z.ZodEnum<{
25549
26009
  full: "full";
25550
- 1: "1";
25551
26010
  2: "2";
26011
+ 1: "1";
25552
26012
  3: "3";
25553
26013
  }>>;
25554
26014
  addedDirsLayout: z.ZodOptional<z.ZodEnum<{
@@ -26086,12 +26546,12 @@ declare const LaunchResolveOutputSchema: z.ZodObject<{
26086
26546
  header: z.ZodOptional<z.ZodArray<z.ZodEnum<{
26087
26547
  identity: "identity";
26088
26548
  model: "model";
26549
+ route: "route";
26089
26550
  account: "account";
26090
26551
  provider: "provider";
26091
26552
  version: "version";
26092
26553
  headroom: "headroom";
26093
26554
  duration: "duration";
26094
- route: "route";
26095
26555
  project: "project";
26096
26556
  vcs: "vcs";
26097
26557
  effort: "effort";
@@ -26587,8 +27047,8 @@ declare const LaunchResolveOutputSchema: z.ZodObject<{
26587
27047
  project: z.ZodOptional<z.ZodObject<{
26588
27048
  pathLevels: z.ZodOptional<z.ZodEnum<{
26589
27049
  full: "full";
26590
- 1: "1";
26591
27050
  2: "2";
27051
+ 1: "1";
26592
27052
  3: "3";
26593
27053
  }>>;
26594
27054
  addedDirsLayout: z.ZodOptional<z.ZodEnum<{
@@ -27930,5 +28390,5 @@ declare const OWN_CLI_FILE_NAME = "cli.cjs";
27930
28390
  */
27931
28391
  declare function agentShimCliPath(distDir?: string | undefined): string;
27932
28392
 
27933
- 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_PENDING_RETIRE_REASONS, 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_SESSION_END_REASONS, RC_SESSION_EVENT_LOG_CAPACITY, 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, RcSessionEventCursorExpiredError, RcSessionEventSchema, RcSessionEventsPageInputSchema, RcSessionEventsReadInputSchema, RcSessionEventsReadOutputSchema, RcSessionEventsStreamInputSchema, RcSessionTransitionSchema, 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, createRcSessionEventLog, createRcSessionEventsApiRouter, createRcSessionRegistryReader, createRcSessionTracker, createRcStreamHub, createSseParser, describeProviderEndpoint, detectAmbientCredential, doorApiAuth, doorApiNodeHandlerOf, effectiveWindow, endRcSession, ensureCa, ensureFrontDoor, ensureHeadroom, evaluateAmbientCredentialGuard, evaluateWhen, fetchThroughWebProxy, followRcSessionEvents, 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, rcStatusWithRegistry, 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, withRegisteredSessionFacts, writeDirectoryRules };
27934
- 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, RcPendingRetireReason, RcPermissionMode, RcPresenceAnswer, RcRateLimitInfo, RcRateLimitWindow, RcReadFileEncoding, RcReadFileOptions, RcRegisteredSession, RcRegistryIdentity, RcSelfHostCredentialRecord, RcSelfHostDeps, RcSelfHostMintResult, RcSelfHostSurface, RcSessionEndReason, RcSessionEvent, RcSessionEventLog, RcSessionEventLogDeps, RcSessionEventsApiDeps, RcSessionEventsApiRouter, RcSessionEventsRead, RcSessionEventsReadInput, RcSessionRegistryDeps, RcSessionRegistryFs, RcSessionStatus, RcSessionSummary, RcSessionTracker, RcSessionTrackerDeps, RcSessionTransition, 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 };
28393
+ 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_GOAL_CLEAR_WORDS, RC_GOAL_CONDITION_MAX_CHARS, RC_IDLE_EXPIRY_MS, RC_ORPC_PATH_PREFIX, RC_PENDING_RETIRE_REASONS, 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_SESSION_COMMAND_MAX_WAIT_MS, RC_SESSION_COMMAND_VERIFIED_VERSIONS, RC_SESSION_END_REASONS, RC_SESSION_EVENT_LOG_CAPACITY, 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, RcSessionEventCursorExpiredError, RcSessionEventSchema, RcSessionEventsPageInputSchema, RcSessionEventsReadInputSchema, RcSessionEventsReadOutputSchema, RcSessionEventsStreamInputSchema, RcSessionTransitionSchema, 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, createRcClaudeCodeVersions, createRcControlHandler, createRcCredentialStore, createRcEventFanout, createRcLiveUsage, createRcSelfHostSurface, createRcSessionCommands, createRcSessionEventLog, createRcSessionEventsApiRouter, createRcSessionRegistryReader, createRcSessionTracker, createRcStreamHub, createSseParser, describeProviderEndpoint, detectAmbientCredential, doorApiAuth, doorApiNodeHandlerOf, effectiveWindow, endRcSession, ensureCa, ensureFrontDoor, ensureHeadroom, evaluateAmbientCredentialGuard, evaluateWhen, fetchThroughWebProxy, followRcSessionEvents, 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, parseRcGoalOutput, parseRcStreamEnvelope, planOf, poolIdentities, poolSelectedByLaunch, prepareClaudeLaunch, prepareLaunch, profileExists, providerExists, rankPool, rcEventWriteResultFromAnswer, rcFanoutOnDoorHub, rcLocalCommandAnswerOf, rcManualCompactBoundaryOf, rcObserverAsPassthrough, rcRateLimitInfoOf, rcSelfHostFromEnv, rcStatusWithRegistry, 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, withRegisteredSessionFacts, writeDirectoryRules };
28394
+ 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, RcClaudeCodeVersions, RcCompactOptions, RcCompactReport, RcContextUsageDetail, RcControlAnswer, RcControlHandlerDeps, RcControlRequestDeps, RcControlTransport, RcCredentialStore, RcDialAnswer, RcDialTarget, RcEventDial, RcEventFanout, RcEventWriteResult, RcExchangeObserver, RcGoal, RcGoalClearReport, RcGoalReport, RcGoalSetReport, RcInjectDeps, RcLiveRateLimit, RcLiveUsage, RcLiveUsageDeps, RcObservedCredential, RcObservedRequest, RcPendingQuestion, RcPendingRequestSummary, RcPendingRetireReason, RcPermissionMode, RcPresenceAnswer, RcQuestionOption, RcQuestionSelection, RcRateLimitInfo, RcRateLimitWindow, RcReadFileEncoding, RcReadFileOptions, RcRegisteredSession, RcRegistryIdentity, RcSelfHostCredentialRecord, RcSelfHostDeps, RcSelfHostMintResult, RcSelfHostSurface, RcSessionCommandDeps, RcSessionCommandOptions, RcSessionCommandResult, RcSessionCommandRoute, RcSessionCommands, RcSessionEndReason, RcSessionEvent, RcSessionEventLog, RcSessionEventLogDeps, RcSessionEventsApiDeps, RcSessionEventsApiRouter, RcSessionEventsRead, RcSessionEventsReadInput, RcSessionRegistryDeps, RcSessionRegistryFs, RcSessionStatus, RcSessionSummary, RcSessionTracker, RcSessionTrackerDeps, RcSessionTransition, RcStreamAnswer, RcStreamDial, RcStreamEnvelope, RcStreamEvent, RcStreamHub, RcStreamHubDeps, RcSupervisedTarget, 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 };