@ref0/sdk 0.6.0 → 0.7.0

package/dist/{index-CJGX88qF.d.mts → index-Vb8-1Zk-.d.mts}

@@ -423,6 +423,8 @@ declare const ApprovalState: Schema.Union<readonly [Schema.Struct<{
   readonly expiresAt: Schema.DateTimeUtcFromString;
 }>, Schema.Struct<{
   readonly state: Schema.Literal<"approved">;
+  /** A machine's answering browser may forget its saved answer once the terminal kept it. */
+  readonly collected: Schema.optionalKey<Schema.Literal<true>>;
 }>, Schema.Struct<{
   readonly state: Schema.Literal<"refused">;
 }>, Schema.Struct<{
@@ -437,6 +439,8 @@ type ApprovalState = typeof ApprovalState.Type;
 /** Only the answering browser receives a machine's answer code; state reads never carry it. */
 declare const ApprovalAnswer: Schema.Union<readonly [Schema.Struct<{
   readonly state: Schema.Literal<"approved">;
+  /** A machine's answering browser may forget its saved answer once the terminal kept it. */
+  readonly collected: Schema.optionalKey<Schema.Literal<true>>;
   readonly answerCode: Schema.String;
 }>, Schema.Struct<{
   readonly status: Schema.Int;
@@ -449,6 +453,8 @@ declare const ApprovalAnswer: Schema.Union<readonly [Schema.Struct<{
   readonly expiresAt: Schema.DateTimeUtcFromString;
 }>, Schema.Struct<{
   readonly state: Schema.Literal<"approved">;
+  /** A machine's answering browser may forget its saved answer once the terminal kept it. */
+  readonly collected: Schema.optionalKey<Schema.Literal<true>>;
 }>, Schema.Struct<{
   readonly state: Schema.Literal<"refused">;
 }>, Schema.Struct<{
@@ -1055,16 +1061,30 @@ declare const AskRecipientNotFound_base: Schema.Class<AskRecipientNotFound, Sche
  * doesn't say, so an ask never says what exists elsewhere.
  */
 declare class AskRecipientNotFound extends AskRecipientNotFound_base {}
+declare const RequestFolder: Schema.Struct<{
+  readonly path: Schema.String;
+  readonly harness: Schema.Literals<readonly ["claude-code", "codex"]>;
+  readonly secretHash: Schema.brand<Schema.String, "SecretHash">;
+  readonly replaces: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["token_", Schema.String]>, "TokenId">>;
+}>;
+type RequestFolder = typeof RequestFolder.Type;
 /** An attachment request, as its person reads it once they type its code. */
 declare const AttachmentRequestView: Schema.Struct<{
   readonly approval: Schema.brand<Schema.TemplateLiteral<readonly ["approval_", Schema.String]>, "ApprovalId">;
   /** The machine's own word for itself, never fact. */
   readonly machineName: Schema.String;
-  /** The harness the machine says it uses, never fact. */
-  readonly harness: Schema.optionalKey<Schema.Literals<readonly ["claude-code", "codex"]>>;
+  readonly folders: Schema.$Array<Schema.Struct<{
+    readonly path: Schema.String;
+    readonly harness: Schema.Literals<readonly ["claude-code", "codex"]>;
+    readonly replaces: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["token_", Schema.String]>, "TokenId">>;
+  }>>;
   readonly askedFrom: Schema.optionalKey<Schema.String>;
   readonly askedAt: Schema.DateTimeUtcFromString;
   readonly expiresAt: Schema.DateTimeUtcFromString;
+  readonly callback: Schema.optionalKey<Schema.Struct<{
+    readonly port: Schema.Int;
+    readonly state: Schema.String;
+  }>>;
 }>;
 type AttachmentRequestView = typeof AttachmentRequestView.Type;
 /**
@@ -1106,10 +1126,137 @@ declare const ConnectChosen: Schema.Struct<{
     readonly organization: Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">;
     readonly name: Schema.brand<Schema.String, "OwnerName">;
   }>>;
+  readonly replacement: Schema.optionalKey<Schema.Struct<{
+    readonly grant: Schema.brand<Schema.TemplateLiteral<readonly ["token_", Schema.String]>, "TokenId">;
+    readonly state: Schema.Literals<readonly ["replaces", "revoked", "skipped"]>;
+    readonly attachedAt: Schema.optionalKey<Schema.DateTimeUtcFromString>;
+  }>>;
 }>;
 type ConnectChosen = typeof ConnectChosen.Type;
+declare const ConnectFolderChoices: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+  readonly path: Schema.String;
+  readonly excluded: Schema.Literal<true>;
+}>, Schema.Struct<{
+  readonly path: Schema.String;
+  readonly agent: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"existing">;
+    readonly agent: Schema.Struct<{
+      readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
+      readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
+    }>;
+  }>, Schema.Struct<{
+    readonly kind: Schema.Literal<"new">;
+    readonly handle: Schema.brand<Schema.String, "AgentHandle">;
+  }>]>;
+}>]>>;
+declare const ConnectFolderOption: Schema.Union<readonly [Schema.Struct<{
+  readonly path: Schema.String;
+  readonly excluded: Schema.Literal<true>;
+}>, Schema.Struct<{
+  readonly path: Schema.String;
+  readonly connect: Schema.Struct<{
+    readonly agent: Schema.optionalKey<Schema.Struct<{
+      readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
+      readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
+    }>>;
+    readonly handle: Schema.brand<Schema.String, "AgentHandle">;
+    readonly organizations: Schema.$Array<Schema.Struct<{
+      readonly organization: Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">;
+      readonly name: Schema.brand<Schema.String, "OwnerName">;
+    }>>;
+    readonly replacement: Schema.optionalKey<Schema.Struct<{
+      readonly grant: Schema.brand<Schema.TemplateLiteral<readonly ["token_", Schema.String]>, "TokenId">;
+      readonly state: Schema.Literals<readonly ["replaces", "revoked", "skipped"]>;
+      readonly attachedAt: Schema.optionalKey<Schema.DateTimeUtcFromString>;
+    }>>;
+  }>;
+}>]>;
+/** Defaults and explicit choices both resolve the entire request and sign one challenge. */
+declare const ConnectOptions: Schema.Struct<{
+  readonly request: Schema.Struct<{
+    readonly approval: Schema.brand<Schema.TemplateLiteral<readonly ["approval_", Schema.String]>, "ApprovalId">;
+    /** The machine's own word for itself, never fact. */
+    readonly machineName: Schema.String;
+    readonly folders: Schema.$Array<Schema.Struct<{
+      readonly path: Schema.String;
+      readonly harness: Schema.Literals<readonly ["claude-code", "codex"]>;
+      readonly replaces: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["token_", Schema.String]>, "TokenId">>;
+    }>>;
+    readonly askedFrom: Schema.optionalKey<Schema.String>;
+    readonly askedAt: Schema.DateTimeUtcFromString;
+    readonly expiresAt: Schema.DateTimeUtcFromString;
+    readonly callback: Schema.optionalKey<Schema.Struct<{
+      readonly port: Schema.Int;
+      readonly state: Schema.String;
+    }>>;
+  }>;
+  readonly agents: Schema.$Array<Schema.Struct<{
+    readonly agent: Schema.Struct<{
+      readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
+      readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
+    }>;
+    readonly handle: Schema.brand<Schema.String, "AgentHandle">;
+  }>>;
+  readonly folders: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+    readonly path: Schema.String;
+    readonly excluded: Schema.Literal<true>;
+  }>, Schema.Struct<{
+    readonly path: Schema.String;
+    readonly connect: Schema.Struct<{
+      readonly agent: Schema.optionalKey<Schema.Struct<{
+        readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
+        readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
+      }>>;
+      readonly handle: Schema.brand<Schema.String, "AgentHandle">;
+      readonly organizations: Schema.$Array<Schema.Struct<{
+        readonly organization: Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">;
+        readonly name: Schema.brand<Schema.String, "OwnerName">;
+      }>>;
+      readonly replacement: Schema.optionalKey<Schema.Struct<{
+        readonly grant: Schema.brand<Schema.TemplateLiteral<readonly ["token_", Schema.String]>, "TokenId">;
+        readonly state: Schema.Literals<readonly ["replaces", "revoked", "skipped"]>;
+        readonly attachedAt: Schema.optionalKey<Schema.DateTimeUtcFromString>;
+      }>>;
+    }>;
+  }>]>>;
+  readonly passkey: Schema.Struct<{
+    readonly challenge: Schema.String;
+    readonly timeout: Schema.optionalKey<Schema.Int>;
+    readonly rpId: Schema.optionalKey<Schema.String>;
+    readonly allowCredentials: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+      readonly id: Schema.String;
+      readonly type: Schema.Literal<"public-key">;
+      readonly transports: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["ble", "cable", "hybrid", "internal", "nfc", "smart-card", "usb"]>>>;
+    }>>>;
+    readonly userVerification: Schema.optionalKey<Schema.Literals<readonly ["discouraged", "preferred", "required"]>>;
+    readonly hints: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["hybrid", "security-key", "client-device"]>>>;
+  }>;
+}>;
+type ConnectOptions = typeof ConnectOptions.Type;
 /** The endpoint an attachment's approval names: no `/v1` endpoint, and never a terminal's ask. */
 declare const connectEndpoint = "attachments.connect";
+declare const FoldersConnected: Schema.Struct<{
+  readonly folders: Schema.$Array<Schema.Struct<{
+    readonly agent: Schema.Struct<{
+      readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
+      readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
+    }>;
+    readonly handle: Schema.brand<Schema.String, "AgentHandle">;
+    readonly credential: Schema.Struct<{
+      readonly person: Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">;
+      readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["token_", Schema.String]>, "TokenId">;
+    }>;
+    readonly agentCreated: Schema.Boolean;
+    readonly path: Schema.String;
+    readonly replacement: Schema.optionalKey<Schema.Struct<{
+      readonly grant: Schema.brand<Schema.TemplateLiteral<readonly ["token_", Schema.String]>, "TokenId">;
+      readonly state: Schema.Literals<readonly ["replaces", "revoked", "skipped"]>;
+      readonly attachedAt: Schema.optionalKey<Schema.DateTimeUtcFromString>;
+    }>>;
+  }>>;
+  readonly excluded: Schema.$Array<Schema.String>;
+}>;
+type FoldersConnected = typeof FoldersConnected.Type;
 declare const AttachmentNotFound_base: Schema.Class<AttachmentNotFound, Schema.TaggedStruct<"AttachmentNotFound", {
   readonly nextStep: Schema.String;
 }>, import("effect/Cause").YieldableError>;
@@ -1946,7 +2093,15 @@ declare const WelcomeGroup_base: HttpApiGroup.HttpApiGroup<"welcome", HttpApiEnd
 }>]>>, Schema.toCodecJson<typeof NameTaken | typeof NameReserved | typeof AuthorityUnavailable>, SignedIn, never>, false>;
 /** Where a signed-in person stands, and naming their owner when their GitHub login couldn't. */
 declare class WelcomeGroup extends WelcomeGroup_base {}
-declare const PasskeysGroup_base: HttpApiGroup.HttpApiGroup<"passkeys", HttpApiEndpoint.HttpApiEndpoint<"firstOptions", "POST", "/v1/me/passkeys/first/options", never, never, never, Schema.toCodecStringTree<Schema.Struct<{
+declare const PasskeysGroup_base: HttpApiGroup.HttpApiGroup<"passkeys", HttpApiEndpoint.HttpApiEndpoint<"list", "GET", "/v1/me/passkeys", never, never, never, never, Schema.toCodecJson<Schema.Struct<{
+  readonly passkeys: Schema.$Array<Schema.Struct<{
+    readonly passkey: Schema.brand<Schema.TemplateLiteral<readonly ["passkey_", Schema.String]>, "PasskeyId">;
+    readonly name: Schema.optionalKey<Schema.String>;
+    readonly createdAt: Schema.String;
+    readonly backedUp: Schema.Boolean;
+  }>>;
+  readonly approvesHere: Schema.Boolean;
+}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"firstOptions", "POST", "/v1/me/passkeys/first/options", never, never, never, Schema.toCodecStringTree<Schema.Struct<{
   'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
 }>>, Schema.toCodecJson<Schema.Struct<{
   readonly rp: Schema.Struct<{
@@ -1977,15 +2132,7 @@ declare const PasskeysGroup_base: HttpApiGroup.HttpApiGroup<"passkeys", HttpApiE
   }>>;
   readonly hints: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["hybrid", "security-key", "client-device"]>>>;
   readonly attestation: Schema.optionalKey<Schema.Literals<readonly ["direct", "enterprise", "indirect", "none"]>>;
-}>>, Schema.toCodecJson<typeof AuthorityUnavailable | typeof PasskeyRefused>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"list", "GET", "/v1/me/passkeys", never, never, never, never, Schema.toCodecJson<Schema.Struct<{
-  readonly passkeys: Schema.$Array<Schema.Struct<{
-    readonly passkey: Schema.brand<Schema.TemplateLiteral<readonly ["passkey_", Schema.String]>, "PasskeyId">;
-    readonly name: Schema.optionalKey<Schema.String>;
-    readonly createdAt: Schema.String;
-    readonly backedUp: Schema.Boolean;
-  }>>;
-  readonly approvesHere: Schema.Boolean;
-}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"enrolFirst", "POST", "/v1/me/passkeys/first", never, never, Schema.toCodecJson<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof AuthorityUnavailable | typeof PasskeyRefused>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"enrolFirst", "POST", "/v1/me/passkeys/first", never, never, Schema.toCodecJson<Schema.Struct<{
   readonly id: Schema.String;
   readonly rawId: Schema.String;
   readonly type: Schema.Literal<"public-key">;
@@ -2020,6 +2167,7 @@ declare const TerminalApprovalsGroup_base: HttpApiGroup.HttpApiGroup<"terminalAp
   readonly expiresAt: Schema.DateTimeUtcFromString;
 }>, Schema.Struct<{
   readonly state: Schema.Literal<"approved">;
+  readonly collected: Schema.optionalKey<Schema.Literal<true>>;
 }>, Schema.Struct<{
   readonly state: Schema.Literal<"refused">;
 }>, Schema.Struct<{
@@ -2095,20 +2243,31 @@ declare const MachineAttachmentsGroup_base: HttpApiGroup.HttpApiGroup<"machineAt
 }>, Schema.Struct<{
   readonly state: Schema.Literal<"connected">;
   readonly owner: Schema.brand<Schema.String, "OwnerName">;
-  readonly agent: Schema.Struct<{
-    readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
-    readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
-  }>;
-  readonly handle: Schema.brand<Schema.String, "AgentHandle">;
-  readonly credential: Schema.Struct<{
-    readonly person: Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">;
-    readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["token_", Schema.String]>, "TokenId">;
-  }>;
-  readonly organizations: Schema.$Array<Schema.Struct<{
-    readonly organization: Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">;
-    readonly name: Schema.brand<Schema.String, "OwnerName">;
-    readonly state: Schema.Literals<readonly ["pending", "authorized", "refused"]>;
+  readonly folders: Schema.$Array<Schema.Struct<{
+    readonly agent: Schema.Struct<{
+      readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
+      readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
+    }>;
+    readonly handle: Schema.brand<Schema.String, "AgentHandle">;
+    readonly credential: Schema.Struct<{
+      readonly person: Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">;
+      readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["token_", Schema.String]>, "TokenId">;
+    }>;
+    readonly agentCreated: Schema.Boolean;
+    readonly path: Schema.String;
+    readonly owner: Schema.brand<Schema.String, "OwnerName">;
+    readonly organizations: Schema.$Array<Schema.Struct<{
+      readonly organization: Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">;
+      readonly name: Schema.brand<Schema.String, "OwnerName">;
+      readonly state: Schema.Literals<readonly ["pending", "authorized", "refused"]>;
+    }>>;
+    readonly replacement: Schema.optionalKey<Schema.Struct<{
+      readonly grant: Schema.brand<Schema.TemplateLiteral<readonly ["token_", Schema.String]>, "TokenId">;
+      readonly state: Schema.Literals<readonly ["replaces", "revoked", "skipped"]>;
+      readonly attachedAt: Schema.optionalKey<Schema.DateTimeUtcFromString>;
+    }>>;
   }>>;
+  readonly excluded: Schema.$Array<Schema.String>;
 }>, Schema.Struct<{
   readonly state: Schema.Literal<"refused">;
 }>, Schema.Struct<{
@@ -2117,7 +2276,7 @@ declare const MachineAttachmentsGroup_base: HttpApiGroup.HttpApiGroup<"machineAt
   readonly state: Schema.Literal<"expired">;
 }>, Schema.Struct<{
   readonly state: Schema.Literal<"failed">;
-  readonly reason: Schema.Literals<readonly ["agent not found", "agent turned off", "agent changed", "handle taken", "session ended", "recovered", "not confirmed"]>;
+  readonly reason: Schema.Literals<readonly ["agent not found", "agent turned off", "agent changed", "handle taken", "session ended", "recovered"]>;
   readonly nextStep: Schema.String;
 }>]>>, Schema.toCodecJson<typeof AuthorityUnavailable | typeof AttachmentNotFound>, ApprovalSecret, never> | HttpApiEndpoint.HttpApiEndpoint<"collect", "POST", "/v1/attachments/requests/:approval/result", Schema.toCodecStringTree<Schema.Struct<{
   approval: Schema.brand<Schema.TemplateLiteral<readonly ["approval_", Schema.String]>, "ApprovalId">;
@@ -2129,20 +2288,31 @@ declare const MachineAttachmentsGroup_base: HttpApiGroup.HttpApiGroup<"machineAt
 }>, Schema.Struct<{
   readonly state: Schema.Literal<"connected">;
   readonly owner: Schema.brand<Schema.String, "OwnerName">;
-  readonly agent: Schema.Struct<{
-    readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
-    readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
-  }>;
-  readonly handle: Schema.brand<Schema.String, "AgentHandle">;
-  readonly credential: Schema.Struct<{
-    readonly person: Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">;
-    readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["token_", Schema.String]>, "TokenId">;
-  }>;
-  readonly organizations: Schema.$Array<Schema.Struct<{
-    readonly organization: Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">;
-    readonly name: Schema.brand<Schema.String, "OwnerName">;
-    readonly state: Schema.Literals<readonly ["pending", "authorized", "refused"]>;
+  readonly folders: Schema.$Array<Schema.Struct<{
+    readonly agent: Schema.Struct<{
+      readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
+      readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
+    }>;
+    readonly handle: Schema.brand<Schema.String, "AgentHandle">;
+    readonly credential: Schema.Struct<{
+      readonly person: Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">;
+      readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["token_", Schema.String]>, "TokenId">;
+    }>;
+    readonly agentCreated: Schema.Boolean;
+    readonly path: Schema.String;
+    readonly owner: Schema.brand<Schema.String, "OwnerName">;
+    readonly organizations: Schema.$Array<Schema.Struct<{
+      readonly organization: Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">;
+      readonly name: Schema.brand<Schema.String, "OwnerName">;
+      readonly state: Schema.Literals<readonly ["pending", "authorized", "refused"]>;
+    }>>;
+    readonly replacement: Schema.optionalKey<Schema.Struct<{
+      readonly grant: Schema.brand<Schema.TemplateLiteral<readonly ["token_", Schema.String]>, "TokenId">;
+      readonly state: Schema.Literals<readonly ["replaces", "revoked", "skipped"]>;
+      readonly attachedAt: Schema.optionalKey<Schema.DateTimeUtcFromString>;
+    }>>;
   }>>;
+  readonly excluded: Schema.$Array<Schema.String>;
 }>, Schema.Struct<{
   readonly state: Schema.Literal<"refused">;
 }>, Schema.Struct<{
@@ -2151,11 +2321,12 @@ declare const MachineAttachmentsGroup_base: HttpApiGroup.HttpApiGroup<"machineAt
   readonly state: Schema.Literal<"expired">;
 }>, Schema.Struct<{
   readonly state: Schema.Literal<"failed">;
-  readonly reason: Schema.Literals<readonly ["agent not found", "agent turned off", "agent changed", "handle taken", "session ended", "recovered", "not confirmed"]>;
+  readonly reason: Schema.Literals<readonly ["agent not found", "agent turned off", "agent changed", "handle taken", "session ended", "recovered"]>;
   readonly nextStep: Schema.String;
 }>]>>, Schema.toCodecJson<typeof AuthorityUnavailable | typeof AttachmentNotFound>, ApprovalSecret, never> | HttpApiEndpoint.HttpApiEndpoint<"confirm", "POST", "/v1/attachments/requests/:approval/collected", Schema.toCodecStringTree<Schema.Struct<{
   approval: Schema.brand<Schema.TemplateLiteral<readonly ["approval_", Schema.String]>, "ApprovalId">;
 }>>, never, Schema.toCodecJson<Schema.Struct<{
+  readonly grants: Schema.$Array<Schema.brand<Schema.TemplateLiteral<readonly ["token_", Schema.String]>, "TokenId">>;
   readonly answerCode: Schema.optionalKey<Schema.String>;
 }>>, Schema.toCodecStringTree<Schema.Struct<{
   'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
@@ -2164,8 +2335,12 @@ declare const MachineAttachmentsGroup_base: HttpApiGroup.HttpApiGroup<"machineAt
 }>>, Schema.toCodecJson<typeof AuthorityUnavailable | typeof AttachmentNotFound>, ApprovalSecret, never> | HttpApiEndpoint.HttpApiEndpoint<"request", "POST", "/v1/attachments/requests", never, never, Schema.toCodecJson<Schema.Struct<{
   readonly machine: Schema.brand<Schema.TemplateLiteral<readonly ["machine_", Schema.String]>, "MachineId">;
   readonly machineName: Schema.String;
-  readonly harness: Schema.optionalKey<Schema.Literals<readonly ["claude-code", "codex"]>>;
-  readonly secretHash: Schema.brand<Schema.String, "SecretHash">;
+  readonly folders: Schema.$Array<Schema.Struct<{
+    readonly path: Schema.String;
+    readonly harness: Schema.Literals<readonly ["claude-code", "codex"]>;
+    readonly secretHash: Schema.brand<Schema.String, "SecretHash">;
+    readonly replaces: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["token_", Schema.String]>, "TokenId">>;
+  }>>;
   readonly collectHash: Schema.brand<Schema.String, "SecretHash">;
   readonly linkHash: Schema.brand<Schema.String, "SecretHash">;
   readonly callback: Schema.optionalKey<Schema.Struct<{
@@ -2425,12 +2600,128 @@ declare const ApprovalsGroup_base: HttpApiGroup.HttpApiGroup<"approvals", HttpAp
   readonly requests: Schema.$Array<Schema.Struct<{
     readonly approval: Schema.brand<Schema.TemplateLiteral<readonly ["approval_", Schema.String]>, "ApprovalId">;
     readonly machineName: Schema.String;
-    readonly harness: Schema.optionalKey<Schema.Literals<readonly ["claude-code", "codex"]>>;
+    readonly folders: Schema.$Array<Schema.Struct<{
+      readonly path: Schema.String;
+      readonly harness: Schema.Literals<readonly ["claude-code", "codex"]>;
+      readonly replaces: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["token_", Schema.String]>, "TokenId">>;
+    }>>;
+    readonly askedFrom: Schema.optionalKey<Schema.String>;
+    readonly askedAt: Schema.DateTimeUtcFromString;
+    readonly expiresAt: Schema.DateTimeUtcFromString;
+    readonly callback: Schema.optionalKey<Schema.Struct<{
+      readonly port: Schema.Int;
+      readonly state: Schema.String;
+    }>>;
+  }>>;
+}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"get", "GET", "/v1/approvals/:approval", Schema.toCodecStringTree<Schema.Struct<{
+  approval: Schema.brand<Schema.TemplateLiteral<readonly ["approval_", Schema.String]>, "ApprovalId">;
+}>>, never, never, never, Schema.toCodecJson<Schema.Union<readonly [Schema.Struct<{
+  readonly state: Schema.Literal<"waiting">;
+  readonly expiresAt: Schema.DateTimeUtcFromString;
+}>, Schema.Struct<{
+  readonly state: Schema.Literal<"approved">;
+  readonly collected: Schema.optionalKey<Schema.Literal<true>>;
+}>, Schema.Struct<{
+  readonly state: Schema.Literal<"refused">;
+}>, Schema.Struct<{
+  readonly state: Schema.Literal<"expired">;
+}>, Schema.Struct<{
+  readonly status: Schema.Int;
+  readonly result: Schema.Codec<Schema.Json, Schema.Json, never, never>;
+  readonly state: Schema.Literal<"ran">;
+  readonly endpoint: Schema.String;
+}>]>>, Schema.toCodecJson<typeof AuthorityUnavailable | typeof ApprovalNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"options", "POST", "/v1/approvals/:approval/options", Schema.toCodecStringTree<Schema.Struct<{
+  approval: Schema.brand<Schema.TemplateLiteral<readonly ["approval_", Schema.String]>, "ApprovalId">;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+  readonly code: Schema.optionalKey<Schema.String>;
+  readonly folders: Schema.optionalKey<Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+    readonly path: Schema.String;
+    readonly excluded: Schema.Literal<true>;
+  }>, Schema.Struct<{
+    readonly path: Schema.String;
+    readonly agent: Schema.Union<readonly [Schema.Struct<{
+      readonly kind: Schema.Literal<"existing">;
+      readonly agent: Schema.Struct<{
+        readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
+        readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
+      }>;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"new">;
+      readonly handle: Schema.brand<Schema.String, "AgentHandle">;
+    }>]>;
+  }>]>>>;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+  'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
+}>>, Schema.toCodecJson<Schema.Union<readonly [Schema.Struct<{
+  readonly challenge: Schema.String;
+  readonly timeout: Schema.optionalKey<Schema.Int>;
+  readonly rpId: Schema.optionalKey<Schema.String>;
+  readonly allowCredentials: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+    readonly id: Schema.String;
+    readonly type: Schema.Literal<"public-key">;
+    readonly transports: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["ble", "cable", "hybrid", "internal", "nfc", "smart-card", "usb"]>>>;
+  }>>>;
+  readonly userVerification: Schema.optionalKey<Schema.Literals<readonly ["discouraged", "preferred", "required"]>>;
+  readonly hints: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["hybrid", "security-key", "client-device"]>>>;
+}>, Schema.Struct<{
+  readonly request: Schema.Struct<{
+    readonly approval: Schema.brand<Schema.TemplateLiteral<readonly ["approval_", Schema.String]>, "ApprovalId">;
+    readonly machineName: Schema.String;
+    readonly folders: Schema.$Array<Schema.Struct<{
+      readonly path: Schema.String;
+      readonly harness: Schema.Literals<readonly ["claude-code", "codex"]>;
+      readonly replaces: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["token_", Schema.String]>, "TokenId">>;
+    }>>;
     readonly askedFrom: Schema.optionalKey<Schema.String>;
     readonly askedAt: Schema.DateTimeUtcFromString;
     readonly expiresAt: Schema.DateTimeUtcFromString;
+    readonly callback: Schema.optionalKey<Schema.Struct<{
+      readonly port: Schema.Int;
+      readonly state: Schema.String;
+    }>>;
+  }>;
+  readonly agents: Schema.$Array<Schema.Struct<{
+    readonly agent: Schema.Struct<{
+      readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
+      readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
+    }>;
+    readonly handle: Schema.brand<Schema.String, "AgentHandle">;
   }>>;
-}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"find", "POST", "/v1/approvals/find", never, never, Schema.toCodecJson<Schema.Union<readonly [Schema.Struct<{
+  readonly folders: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+    readonly path: Schema.String;
+    readonly excluded: Schema.Literal<true>;
+  }>, Schema.Struct<{
+    readonly path: Schema.String;
+    readonly connect: Schema.Struct<{
+      readonly agent: Schema.optionalKey<Schema.Struct<{
+        readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
+        readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
+      }>>;
+      readonly handle: Schema.brand<Schema.String, "AgentHandle">;
+      readonly organizations: Schema.$Array<Schema.Struct<{
+        readonly organization: Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">;
+        readonly name: Schema.brand<Schema.String, "OwnerName">;
+      }>>;
+      readonly replacement: Schema.optionalKey<Schema.Struct<{
+        readonly grant: Schema.brand<Schema.TemplateLiteral<readonly ["token_", Schema.String]>, "TokenId">;
+        readonly state: Schema.Literals<readonly ["replaces", "revoked", "skipped"]>;
+        readonly attachedAt: Schema.optionalKey<Schema.DateTimeUtcFromString>;
+      }>>;
+    }>;
+  }>]>>;
+  readonly passkey: Schema.Struct<{
+    readonly challenge: Schema.String;
+    readonly timeout: Schema.optionalKey<Schema.Int>;
+    readonly rpId: Schema.optionalKey<Schema.String>;
+    readonly allowCredentials: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+      readonly id: Schema.String;
+      readonly type: Schema.Literal<"public-key">;
+      readonly transports: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["ble", "cable", "hybrid", "internal", "nfc", "smart-card", "usb"]>>>;
+    }>>>;
+    readonly userVerification: Schema.optionalKey<Schema.Literals<readonly ["discouraged", "preferred", "required"]>>;
+    readonly hints: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["hybrid", "security-key", "client-device"]>>>;
+  }>;
+}>]>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof PasskeyRefused | typeof AttachmentFailed | typeof ApprovalNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"find", "POST", "/v1/approvals/find", never, never, Schema.toCodecJson<Schema.Union<readonly [Schema.Struct<{
   readonly code: Schema.String;
 }>, Schema.Struct<{
   readonly link: Schema.String;
@@ -2649,102 +2940,19 @@ declare const ApprovalsGroup_base: HttpApiGroup.HttpApiGroup<"approvals", HttpAp
 }>, Schema.Struct<{
   readonly approval: Schema.brand<Schema.TemplateLiteral<readonly ["approval_", Schema.String]>, "ApprovalId">;
   readonly machineName: Schema.String;
-  readonly harness: Schema.optionalKey<Schema.Literals<readonly ["claude-code", "codex"]>>;
+  readonly folders: Schema.$Array<Schema.Struct<{
+    readonly path: Schema.String;
+    readonly harness: Schema.Literals<readonly ["claude-code", "codex"]>;
+    readonly replaces: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["token_", Schema.String]>, "TokenId">>;
+  }>>;
   readonly askedFrom: Schema.optionalKey<Schema.String>;
   readonly askedAt: Schema.DateTimeUtcFromString;
   readonly expiresAt: Schema.DateTimeUtcFromString;
-}>]>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof ApprovalNotFound | typeof SlowDown>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"get", "GET", "/v1/approvals/:approval", Schema.toCodecStringTree<Schema.Struct<{
-  approval: Schema.brand<Schema.TemplateLiteral<readonly ["approval_", Schema.String]>, "ApprovalId">;
-}>>, never, never, never, Schema.toCodecJson<Schema.Union<readonly [Schema.Struct<{
-  readonly state: Schema.Literal<"waiting">;
-  readonly expiresAt: Schema.DateTimeUtcFromString;
-}>, Schema.Struct<{
-  readonly state: Schema.Literal<"approved">;
-}>, Schema.Struct<{
-  readonly state: Schema.Literal<"refused">;
-}>, Schema.Struct<{
-  readonly state: Schema.Literal<"expired">;
-}>, Schema.Struct<{
-  readonly status: Schema.Int;
-  readonly result: Schema.Codec<Schema.Json, Schema.Json, never, never>;
-  readonly state: Schema.Literal<"ran">;
-  readonly endpoint: Schema.String;
-}>]>>, Schema.toCodecJson<typeof AuthorityUnavailable | typeof ApprovalNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"options", "POST", "/v1/approvals/:approval/options", Schema.toCodecStringTree<Schema.Struct<{
-  approval: Schema.brand<Schema.TemplateLiteral<readonly ["approval_", Schema.String]>, "ApprovalId">;
-}>>, never, Schema.toCodecJson<Schema.Struct<{
-  readonly code: Schema.optionalKey<Schema.String>;
-  readonly agent: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
-    readonly kind: Schema.Literal<"existing">;
-    readonly agent: Schema.Struct<{
-      readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
-      readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
-    }>;
-  }>, Schema.Struct<{
-    readonly kind: Schema.Literal<"new">;
-    readonly handle: Schema.brand<Schema.String, "AgentHandle">;
-  }>]>>;
-}>>, Schema.toCodecStringTree<Schema.Struct<{
-  'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
-}>>, Schema.toCodecJson<Schema.Union<readonly [Schema.Struct<{
-  readonly challenge: Schema.String;
-  readonly timeout: Schema.optionalKey<Schema.Int>;
-  readonly rpId: Schema.optionalKey<Schema.String>;
-  readonly allowCredentials: Schema.optionalKey<Schema.$Array<Schema.Struct<{
-    readonly id: Schema.String;
-    readonly type: Schema.Literal<"public-key">;
-    readonly transports: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["ble", "cable", "hybrid", "internal", "nfc", "smart-card", "usb"]>>>;
-  }>>>;
-  readonly userVerification: Schema.optionalKey<Schema.Literals<readonly ["discouraged", "preferred", "required"]>>;
-  readonly hints: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["hybrid", "security-key", "client-device"]>>>;
-}>, Schema.Union<readonly [Schema.Struct<{
-  readonly request: Schema.Struct<{
-    readonly approval: Schema.brand<Schema.TemplateLiteral<readonly ["approval_", Schema.String]>, "ApprovalId">;
-    readonly machineName: Schema.String;
-    readonly harness: Schema.optionalKey<Schema.Literals<readonly ["claude-code", "codex"]>>;
-    readonly askedFrom: Schema.optionalKey<Schema.String>;
-    readonly askedAt: Schema.DateTimeUtcFromString;
-    readonly expiresAt: Schema.DateTimeUtcFromString;
-  }>;
-  readonly agents: Schema.$Array<Schema.Struct<{
-    readonly agent: Schema.Struct<{
-      readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
-      readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
-    }>;
-    readonly handle: Schema.brand<Schema.String, "AgentHandle">;
+  readonly callback: Schema.optionalKey<Schema.Struct<{
+    readonly port: Schema.Int;
+    readonly state: Schema.String;
   }>>;
-}>, Schema.Struct<{
-  readonly request: Schema.Struct<{
-    readonly approval: Schema.brand<Schema.TemplateLiteral<readonly ["approval_", Schema.String]>, "ApprovalId">;
-    readonly machineName: Schema.String;
-    readonly harness: Schema.optionalKey<Schema.Literals<readonly ["claude-code", "codex"]>>;
-    readonly askedFrom: Schema.optionalKey<Schema.String>;
-    readonly askedAt: Schema.DateTimeUtcFromString;
-    readonly expiresAt: Schema.DateTimeUtcFromString;
-  }>;
-  readonly connect: Schema.Struct<{
-    readonly agent: Schema.optionalKey<Schema.Struct<{
-      readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
-      readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
-    }>>;
-    readonly handle: Schema.brand<Schema.String, "AgentHandle">;
-    readonly organizations: Schema.$Array<Schema.Struct<{
-      readonly organization: Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">;
-      readonly name: Schema.brand<Schema.String, "OwnerName">;
-    }>>;
-  }>;
-  readonly passkey: Schema.Struct<{
-    readonly challenge: Schema.String;
-    readonly timeout: Schema.optionalKey<Schema.Int>;
-    readonly rpId: Schema.optionalKey<Schema.String>;
-    readonly allowCredentials: Schema.optionalKey<Schema.$Array<Schema.Struct<{
-      readonly id: Schema.String;
-      readonly type: Schema.Literal<"public-key">;
-      readonly transports: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["ble", "cable", "hybrid", "internal", "nfc", "smart-card", "usb"]>>>;
-    }>>>;
-    readonly userVerification: Schema.optionalKey<Schema.Literals<readonly ["discouraged", "preferred", "required"]>>;
-    readonly hints: Schema.optionalKey<Schema.$Array<Schema.Literals<readonly ["hybrid", "security-key", "client-device"]>>>;
-  }>;
-}>]>]>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof PasskeyRefused | typeof AttachmentFailed | typeof ApprovalNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"answer", "POST", "/v1/approvals/:approval/answer", Schema.toCodecStringTree<Schema.Struct<{
+}>]>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof ApprovalNotFound | typeof SlowDown>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"answer", "POST", "/v1/approvals/:approval/answer", Schema.toCodecStringTree<Schema.Struct<{
   approval: Schema.brand<Schema.TemplateLiteral<readonly ["approval_", Schema.String]>, "ApprovalId">;
 }>>, never, Schema.toCodecJson<Schema.Union<readonly [Schema.Struct<{
   readonly answer: Schema.Literal<"yes">;
@@ -2794,6 +3002,7 @@ declare const ApprovalsGroup_base: HttpApiGroup.HttpApiGroup<"approvals", HttpAp
   'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
 }>>, Schema.toCodecJson<Schema.Union<readonly [Schema.Struct<{
   readonly state: Schema.Literal<"approved">;
+  readonly collected: Schema.optionalKey<Schema.Literal<true>>;
   readonly answerCode: Schema.String;
 }>, Schema.Struct<{
   readonly status: Schema.Int;
@@ -2806,6 +3015,7 @@ declare const ApprovalsGroup_base: HttpApiGroup.HttpApiGroup<"approvals", HttpAp
   readonly expiresAt: Schema.DateTimeUtcFromString;
 }>, Schema.Struct<{
   readonly state: Schema.Literal<"approved">;
+  readonly collected: Schema.optionalKey<Schema.Literal<true>>;
 }>, Schema.Struct<{
   readonly state: Schema.Literal<"refused">;
 }>, Schema.Struct<{
@@ -2856,42 +3066,7 @@ declare const MeGroup_base: HttpApiGroup.HttpApiGroup<"me", HttpApiEndpoint.Http
     readonly action: Schema.Literals<readonly ["project:read", "project:write", "thread:start", "thread:write", "session:start", "session:change", "agent:attach", "approval:start", "git:read", "git:push", "approval:ask", "repo:add", "project:create", "thread:watch", "check:run"]>;
   }>>;
   readonly expiresAt: Schema.optionalKey<Schema.DateTimeUtcFromMillis>;
-}>>, never, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"renew", "POST", "/v1/me/renew", never, never, never, Schema.toCodecStringTree<Schema.Struct<{
-  'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
-}>>, Schema.toCodecJson<Schema.Struct<{
-  readonly expiresAt: Schema.DateTimeUtcFromMillis;
-}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"mirrors", "GET", "/v1/me/mirrors", never, never, never, never, Schema.toCodecJson<Schema.Struct<{
-  readonly mirrors: Schema.$Array<Schema.Struct<{
-    readonly repo: Schema.brand<Schema.TemplateLiteral<readonly ["repo_", Schema.String]>, "RepoId">;
-    readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
-    readonly ownerName: Schema.brand<Schema.String, "OwnerName">;
-    readonly name: Schema.brand<Schema.String, "RepoName">;
-    readonly mirror: Schema.Union<readonly [Schema.Struct<{
-      readonly kind: Schema.Literal<"none">;
-    }>, Schema.Struct<{
-      readonly kind: Schema.Literal<"github">;
-      readonly branch: Schema.String;
-      readonly mirror: Schema.Union<readonly [Schema.Struct<{
-        readonly state: Schema.Literal<"on">;
-      }>, Schema.Struct<{
-        readonly state: Schema.Literal<"paused">;
-        readonly paused: Schema.Union<readonly [Schema.Struct<{
-          readonly why: Schema.Literal<"diverged">;
-          readonly github: Schema.NullOr<Schema.brand<Schema.String, "CommitOid">>;
-        }>, Schema.Struct<{
-          readonly why: Schema.Literal<"refused">;
-          readonly said: Schema.String;
-        }>, Schema.Struct<{
-          readonly why: Schema.Literal<"unauthorized">;
-        }>]>;
-      }>, Schema.Struct<{
-        readonly state: Schema.Literal<"off">;
-      }>]>;
-      readonly lastMirrored: Schema.NullOr<Schema.brand<Schema.String, "CommitOid">>;
-      readonly nextStep: Schema.optionalKey<Schema.String>;
-    }>]>;
-  }>>;
-}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"usage", "GET", "/v1/me/usage", never, Schema.toCodecStringTree<Schema.Struct<{
+}>>, never, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"usage", "GET", "/v1/me/usage", never, Schema.toCodecStringTree<Schema.Struct<{
   from: Schema.optionalKey<Schema.brand<Schema.String, "UtcDay">>;
   to: Schema.optionalKey<Schema.brand<Schema.String, "UtcDay">>;
 }>>, never, never, Schema.toCodecJson<Schema.Struct<{
@@ -2964,7 +3139,42 @@ declare const MeGroup_base: HttpApiGroup.HttpApiGroup<"me", HttpApiEndpoint.Http
       readonly bytes: Schema.Int;
     }>>>;
   }>>;
-}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof UsageRangeRefused>, Authorization, never>, false>;
+}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof UsageRangeRefused>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"mirrors", "GET", "/v1/me/mirrors", never, never, never, never, Schema.toCodecJson<Schema.Struct<{
+  readonly mirrors: Schema.$Array<Schema.Struct<{
+    readonly repo: Schema.brand<Schema.TemplateLiteral<readonly ["repo_", Schema.String]>, "RepoId">;
+    readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
+    readonly ownerName: Schema.brand<Schema.String, "OwnerName">;
+    readonly name: Schema.brand<Schema.String, "RepoName">;
+    readonly mirror: Schema.Union<readonly [Schema.Struct<{
+      readonly kind: Schema.Literal<"none">;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"github">;
+      readonly branch: Schema.String;
+      readonly mirror: Schema.Union<readonly [Schema.Struct<{
+        readonly state: Schema.Literal<"on">;
+      }>, Schema.Struct<{
+        readonly state: Schema.Literal<"paused">;
+        readonly paused: Schema.Union<readonly [Schema.Struct<{
+          readonly why: Schema.Literal<"diverged">;
+          readonly github: Schema.NullOr<Schema.brand<Schema.String, "CommitOid">>;
+        }>, Schema.Struct<{
+          readonly why: Schema.Literal<"refused">;
+          readonly said: Schema.String;
+        }>, Schema.Struct<{
+          readonly why: Schema.Literal<"unauthorized">;
+        }>]>;
+      }>, Schema.Struct<{
+        readonly state: Schema.Literal<"off">;
+      }>]>;
+      readonly lastMirrored: Schema.NullOr<Schema.brand<Schema.String, "CommitOid">>;
+      readonly nextStep: Schema.optionalKey<Schema.String>;
+    }>]>;
+  }>>;
+}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"renew", "POST", "/v1/me/renew", never, never, never, Schema.toCodecStringTree<Schema.Struct<{
+  'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
+}>>, Schema.toCodecJson<Schema.Struct<{
+  readonly expiresAt: Schema.DateTimeUtcFromMillis;
+}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable>, Authorization, never>, false>;
 declare class MeGroup extends MeGroup_base {}
 declare const ThreadsGroup_base: HttpApiGroup.HttpApiGroup<"threads", HttpApiEndpoint.HttpApiEndpoint<"ask", "POST", "/v1/projects/:owner/:project/threads/:number/asks", Schema.toCodecStringTree<Schema.Struct<{
   owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
@@ -12460,127 +12670,114 @@ declare const OwnerThreadsGroup_base: HttpApiGroup.HttpApiGroup<"ownerThreads",
  * the stage as filters. A project the reader can't see answers as one that isn't there.
  */
 declare class OwnerThreadsGroup extends OwnerThreadsGroup_base {}
-declare const ReposGroup_base: HttpApiGroup.HttpApiGroup<"repos", HttpApiEndpoint.HttpApiEndpoint<"list", "GET", "/v1/owners/:owner/repos", Schema.toCodecStringTree<Schema.Struct<{
+declare const ReposGroup_base: HttpApiGroup.HttpApiGroup<"repos", HttpApiEndpoint.HttpApiEndpoint<"pack", "GET", "/v1/repos/:owner/:repo/history/packs", Schema.toCodecStringTree<Schema.Struct<{
   owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
+  repo: Schema.brand<Schema.String, "RepoName">;
 }>>, Schema.toCodecStringTree<Schema.Struct<{
-  after: Schema.optionalKey<Schema.brand<Schema.String, "RepoName">>;
-  limit: Schema.optionalKey<Schema.Int>;
+  key: Schema.String;
+}>>, never, never, HttpApiSchema.StreamUint8Array, Schema.toCodecJson<typeof RepoNotFound | typeof HistoryPackNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"line", "GET", "/v1/repos/:owner/:repo/commits/:commit/lines", Schema.toCodecStringTree<Schema.Struct<{
+  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
+  repo: Schema.brand<Schema.String, "RepoName">;
+  commit: Schema.brand<Schema.String, "CommitOid">;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+  path: Schema.brand<Schema.String, "RepoPath">;
+  line: Schema.Int;
 }>>, never, never, Schema.toCodecJson<Schema.Struct<{
-  readonly repos: Schema.$Array<Schema.Struct<{
+  readonly commit: Schema.brand<Schema.String, "CommitOid">;
+  readonly path: Schema.brand<Schema.String, "RepoPath">;
+  readonly line: Schema.Int;
+  readonly from: Schema.Literals<readonly ["session", "workflow", "main", "unknown"]>;
+  readonly authorship: Schema.Literals<readonly ["ai", "human", "mixed", "unknown"]>;
+  readonly turns: Schema.$Array<Schema.Struct<{
+    readonly thread: Schema.brand<Schema.TemplateLiteral<readonly ["thread_", Schema.String]>, "ThreadId">;
+    readonly threadNumber: Schema.Int;
+    readonly session: Schema.brand<Schema.TemplateLiteral<readonly ["session_", Schema.String]>, "SessionId">;
+    readonly turn: Schema.Int;
+    readonly authorship: Schema.Literals<readonly ["ai", "human", "mixed", "unknown"]>;
+    readonly model: Schema.optionalKey<Schema.String>;
+  }>>;
+  readonly workflow: Schema.optionalKey<Schema.Struct<{
+    readonly name: Schema.brand<Schema.String, "WorkflowName">;
+    readonly run: Schema.brand<Schema.TemplateLiteral<readonly ["workflowrun_", Schema.String]>, "WorkflowRunId">;
+    readonly version: Schema.brand<Schema.String, "WorkflowVersion">;
+    readonly step: Schema.Struct<{
+      readonly name: Schema.String;
+      readonly count: Schema.Int;
+      readonly attempt: Schema.Int;
+    }>;
+  }>>;
+}>>, Schema.toCodecJson<typeof RepoNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"projectGate", "GET", "/v1/repos/:owner/:repo/project-gate", Schema.toCodecStringTree<Schema.Struct<{
+  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
+  repo: Schema.brand<Schema.String, "RepoName">;
+}>>, never, never, never, Schema.toCodecJson<Schema.Struct<{
+  readonly active: Schema.Struct<{
+    readonly revision: Schema.Int;
+    readonly commit: Schema.NullOr<Schema.brand<Schema.String, "CommitOid">>;
+    readonly repo: Schema.NullOr<Schema.brand<Schema.TemplateLiteral<readonly ["repo_", Schema.String]>, "RepoId">>;
+  }>;
+  readonly pending: Schema.optionalKey<Schema.Struct<{
+    readonly revision: Schema.Int;
+    readonly commit: Schema.NullOr<Schema.brand<Schema.String, "CommitOid">>;
+    readonly repo: Schema.NullOr<Schema.brand<Schema.TemplateLiteral<readonly ["repo_", Schema.String]>, "RepoId">>;
+  }>>;
+  readonly holding: Schema.$Array<Schema.Struct<{
     readonly repo: Schema.brand<Schema.TemplateLiteral<readonly ["repo_", Schema.String]>, "RepoId">;
-    readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
-    readonly project: Schema.brand<Schema.TemplateLiteral<readonly ["project_", Schema.String]>, "ProjectId">;
-    readonly scope: Schema.Union<readonly [Schema.Struct<{
-      readonly kind: Schema.Literal<"project">;
-      readonly name: Schema.brand<Schema.String, "ProjectName">;
-    }>, Schema.Struct<{
-      readonly kind: Schema.Literal<"owner">;
-    }>]>;
-    readonly name: Schema.brand<Schema.String, "RepoName">;
-    readonly visibility: Schema.Literals<readonly ["private", "internal", "public"]>;
-    readonly state: Schema.Literals<readonly ["creating", "importing", "ready", "failed"]>;
-    readonly createdAt: Schema.DateTimeUtcFromMillis;
+    readonly latch: Schema.brand<Schema.TemplateLiteral<readonly ["latch_", Schema.String]>, "LatchId">;
+    readonly thread: Schema.brand<Schema.TemplateLiteral<readonly ["thread_", Schema.String]>, "ThreadId">;
+    readonly version: Schema.brand<Schema.TemplateLiteral<readonly ["version_", Schema.String]>, "VersionId">;
+    readonly gate: Schema.Int;
+    readonly since: Schema.Int;
   }>>;
-  readonly nextAfter: Schema.optionalKey<Schema.brand<Schema.String, "RepoName">>;
-}>>, never, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"get", "GET", "/v1/repos/:owner/:repo", Schema.toCodecStringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof RepoNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"pull", "GET", "/v1/repos/:owner/:repo/pulls/:pullRequest", Schema.toCodecStringTree<Schema.Struct<{
   owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
   repo: Schema.brand<Schema.String, "RepoName">;
+  pullRequest: Schema.brand<Schema.Int, "PullRequestNumber">;
 }>>, never, never, never, Schema.toCodecJson<Schema.Struct<{
-  readonly repo: Schema.brand<Schema.TemplateLiteral<readonly ["repo_", Schema.String]>, "RepoId">;
-  readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
-  readonly project: Schema.brand<Schema.TemplateLiteral<readonly ["project_", Schema.String]>, "ProjectId">;
-  readonly scope: Schema.Union<readonly [Schema.Struct<{
-    readonly kind: Schema.Literal<"project">;
-    readonly name: Schema.brand<Schema.String, "ProjectName">;
+  readonly pullRequest: Schema.brand<Schema.Int, "PullRequestNumber">;
+  readonly thread: Schema.brand<Schema.TemplateLiteral<readonly ["thread_", Schema.String]>, "ThreadId">;
+  readonly state: Schema.Literals<readonly ["open", "merged", "closed"]>;
+  readonly head: Schema.Struct<{
+    readonly gitRepository: Schema.brand<Schema.TemplateLiteral<readonly ["gitrepo_", Schema.String]>, "GitRepositoryId">;
+    readonly fork: Schema.brand<Schema.TemplateLiteral<readonly ["fork_", Schema.String]>, "ForkId">;
+    readonly branch: Schema.String;
+    readonly commit: Schema.brand<Schema.String, "CommitOid">;
+    readonly generation: Schema.Int;
+  }>;
+  readonly openedBy: Schema.Union<readonly [Schema.Struct<{
+    readonly session: Schema.brand<Schema.TemplateLiteral<readonly ["session_", Schema.String]>, "SessionId">;
+    readonly agent: Schema.Struct<{
+      readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
+      readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
+    }>;
   }>, Schema.Struct<{
-    readonly kind: Schema.Literal<"owner">;
+    readonly workflow: Schema.Struct<{
+      readonly name: Schema.brand<Schema.String, "WorkflowName">;
+      readonly run: Schema.brand<Schema.TemplateLiteral<readonly ["workflowrun_", Schema.String]>, "WorkflowRunId">;
+      readonly version: Schema.brand<Schema.String, "WorkflowVersion">;
+      readonly step: Schema.Struct<{
+        readonly name: Schema.String;
+        readonly count: Schema.Int;
+        readonly attempt: Schema.Int;
+      }>;
+    }>;
   }>]>;
-  readonly name: Schema.brand<Schema.String, "RepoName">;
-  readonly visibility: Schema.Literals<readonly ["private", "internal", "public"]>;
-  readonly state: Schema.Literals<readonly ["creating", "importing", "ready", "failed"]>;
-  readonly createdAt: Schema.DateTimeUtcFromMillis;
-}>>, Schema.toCodecJson<typeof RepoNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"create", "POST", "/v1/owners/:owner/repos", Schema.toCodecStringTree<Schema.Struct<{
-  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
-}>>, never, Schema.toCodecJson<Schema.Struct<{
-  readonly name: Schema.brand<Schema.String, "RepoName">;
-  readonly project: Schema.optionalKey<Schema.brand<Schema.String, "ProjectName">>;
-}>>, Schema.toCodecStringTree<Schema.Struct<{
-  'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
-}>>, Schema.toCodecJson<Schema.Struct<{
-  readonly repo: Schema.brand<Schema.TemplateLiteral<readonly ["repo_", Schema.String]>, "RepoId">;
-  readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
-  readonly project: Schema.brand<Schema.TemplateLiteral<readonly ["project_", Schema.String]>, "ProjectId">;
-  readonly scope: Schema.Union<readonly [Schema.Struct<{
-    readonly kind: Schema.Literal<"project">;
-    readonly name: Schema.brand<Schema.String, "ProjectName">;
-  }>, Schema.Struct<{
-    readonly kind: Schema.Literal<"owner">;
-  }>]>;
-  readonly name: Schema.brand<Schema.String, "RepoName">;
-  readonly visibility: Schema.Literals<readonly ["private", "internal", "public"]>;
-  readonly state: Schema.Literals<readonly ["creating", "importing", "ready", "failed"]>;
-  readonly createdAt: Schema.DateTimeUtcFromMillis;
-}>>, Schema.toCodecJson<typeof NameTaken | typeof NameReserved | typeof ProjectNotFound | typeof NotPermitted | typeof AuthorityUnavailable | typeof DeliveryOutsideWindow | typeof CommandRefused | typeof ApprovalNeeded | typeof SlowDown>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"import", "POST", "/v1/owners/:owner/repos/import", Schema.toCodecStringTree<Schema.Struct<{
-  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
-}>>, never, Schema.toCodecJson<Schema.Struct<{
-  readonly name: Schema.brand<Schema.String, "RepoName">;
-  readonly project: Schema.optionalKey<Schema.brand<Schema.String, "ProjectName">>;
-  readonly url: Schema.brand<Schema.String, "RepoUrl">;
-}>>, Schema.toCodecStringTree<Schema.Struct<{
-  'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
-}>>, Schema.toCodecJson<Schema.Struct<{
-  readonly repo: Schema.brand<Schema.TemplateLiteral<readonly ["repo_", Schema.String]>, "RepoId">;
-  readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
-  readonly project: Schema.brand<Schema.TemplateLiteral<readonly ["project_", Schema.String]>, "ProjectId">;
-  readonly scope: Schema.Union<readonly [Schema.Struct<{
-    readonly kind: Schema.Literal<"project">;
-    readonly name: Schema.brand<Schema.String, "ProjectName">;
-  }>, Schema.Struct<{
-    readonly kind: Schema.Literal<"owner">;
-  }>]>;
-  readonly name: Schema.brand<Schema.String, "RepoName">;
-  readonly visibility: Schema.Literals<readonly ["private", "internal", "public"]>;
-  readonly state: Schema.Literals<readonly ["creating", "importing", "ready", "failed"]>;
-  readonly createdAt: Schema.DateTimeUtcFromMillis;
-}>>, Schema.toCodecJson<typeof NameTaken | typeof NameReserved | typeof ProjectNotFound | typeof NotPermitted | typeof AuthorityUnavailable | typeof DeliveryOutsideWindow | typeof CommandRefused | typeof ApprovalNeeded | typeof SlowDown>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"manifest", "GET", "/v1/repos/:owner/:repo/history/manifest", Schema.toCodecStringTree<Schema.Struct<{
-  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
-  repo: Schema.brand<Schema.String, "RepoName">;
-}>>, never, never, never, Schema.toCodecJson<Schema.Struct<{
-  readonly repo: Schema.brand<Schema.TemplateLiteral<readonly ["repo_", Schema.String]>, "RepoId">;
-  readonly version: Schema.Int;
-  readonly baseline: Schema.Struct<{
-    readonly gitRepository: Schema.brand<Schema.TemplateLiteral<readonly ["gitrepo_", Schema.String]>, "GitRepositoryId">;
-    readonly tip: Schema.brand<Schema.String, "CommitOid">;
-    readonly sequence: Schema.Int;
-    readonly depth: Schema.Int;
-    readonly boundary: Schema.$Array<Schema.brand<Schema.String, "CommitOid">>;
+  readonly openedAt: Schema.DateTimeUtcFromMillis;
+  readonly closedAt: Schema.NullOr<Schema.DateTimeUtcFromMillis>;
+  readonly closedWhy: Schema.NullOr<Schema.Literals<readonly ["closed", "thread closed", "fork deleted"]>>;
+  readonly repair: Schema.Boolean;
+  readonly current: Schema.Struct<{
+    readonly version: Schema.brand<Schema.Int, "VersionNumber">;
+    readonly head: Schema.brand<Schema.String, "CommitOid">;
+    readonly base: Schema.NullOr<Schema.brand<Schema.String, "CommitOid">>;
+    readonly planVersion: Schema.NullOr<Schema.Int>;
+    readonly intentRevision: Schema.Int;
+    readonly generation: Schema.Int;
+    readonly state: Schema.Literals<readonly ["preparing", "evaluating", "gating", "waiting", "queued", "publishing", "merged", "superseded", "stale", "conflicted"]>;
+    readonly why: Schema.Literals<readonly ["opened", "push", "head set", "main moved", ".ref0/ changed", "outcomes changed", "intent changed", "needs changed", "project gate changed"]>;
+    readonly createdAt: Schema.DateTimeUtcFromMillis;
   }>;
-  readonly main: Schema.optionalKey<Schema.Struct<{
-    readonly sequence: Schema.Int;
-    readonly commit: Schema.brand<Schema.String, "CommitOid">;
-  }>>;
-  readonly packs: Schema.$Array<Schema.Struct<{
-    readonly kind: Schema.Literals<readonly ["base", "baseline", "deepen", "merge", "rollup"]>;
-    readonly key: Schema.String;
-    readonly sha256: Schema.String;
-    readonly bytes: Schema.Int;
-    readonly merges: Schema.optionalKey<Schema.Struct<{
-      readonly first: Schema.Int;
-      readonly last: Schema.Int;
-    }>>;
-    readonly baseline: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["gitrepo_", Schema.String]>, "GitRepositoryId">>;
-    readonly depth: Schema.optionalKey<Schema.Int>;
-    readonly roots: Schema.$Array<Schema.Struct<{
-      readonly commit: Schema.brand<Schema.String, "CommitOid">;
-      readonly parents: Schema.$Array<Schema.brand<Schema.String, "CommitOid">>;
-    }>>;
-  }>>;
-}>>, Schema.toCodecJson<typeof RepoNotFound | typeof HistoryNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"pack", "GET", "/v1/repos/:owner/:repo/history/packs", Schema.toCodecStringTree<Schema.Struct<{
-  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
-  repo: Schema.brand<Schema.String, "RepoName">;
-}>>, Schema.toCodecStringTree<Schema.Struct<{
-  key: Schema.String;
-}>>, never, never, HttpApiSchema.StreamUint8Array, Schema.toCodecJson<typeof RepoNotFound | typeof HistoryPackNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"pulls", "GET", "/v1/repos/:owner/:repo/pulls", Schema.toCodecStringTree<Schema.Struct<{
+  readonly threadNumber: Schema.Int;
+}>>, Schema.toCodecJson<typeof PullRequestNotFound | typeof RepoNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"pulls", "GET", "/v1/repos/:owner/:repo/pulls", Schema.toCodecStringTree<Schema.Struct<{
   owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
   repo: Schema.brand<Schema.String, "RepoName">;
 }>>, Schema.toCodecStringTree<Schema.Struct<{
@@ -12632,56 +12829,46 @@ declare const ReposGroup_base: HttpApiGroup.HttpApiGroup<"repos", HttpApiEndpoin
     }>;
     readonly threadNumber: Schema.Int;
   }>>;
-}>>, Schema.toCodecJson<typeof RepoNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"pull", "GET", "/v1/repos/:owner/:repo/pulls/:pullRequest", Schema.toCodecStringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof RepoNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"get", "GET", "/v1/repos/:owner/:repo", Schema.toCodecStringTree<Schema.Struct<{
   owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
   repo: Schema.brand<Schema.String, "RepoName">;
-  pullRequest: Schema.brand<Schema.Int, "PullRequestNumber">;
 }>>, never, never, never, Schema.toCodecJson<Schema.Struct<{
-  readonly pullRequest: Schema.brand<Schema.Int, "PullRequestNumber">;
-  readonly thread: Schema.brand<Schema.TemplateLiteral<readonly ["thread_", Schema.String]>, "ThreadId">;
-  readonly state: Schema.Literals<readonly ["open", "merged", "closed"]>;
-  readonly head: Schema.Struct<{
-    readonly gitRepository: Schema.brand<Schema.TemplateLiteral<readonly ["gitrepo_", Schema.String]>, "GitRepositoryId">;
-    readonly fork: Schema.brand<Schema.TemplateLiteral<readonly ["fork_", Schema.String]>, "ForkId">;
-    readonly branch: Schema.String;
-    readonly commit: Schema.brand<Schema.String, "CommitOid">;
-    readonly generation: Schema.Int;
-  }>;
-  readonly openedBy: Schema.Union<readonly [Schema.Struct<{
-    readonly session: Schema.brand<Schema.TemplateLiteral<readonly ["session_", Schema.String]>, "SessionId">;
-    readonly agent: Schema.Struct<{
-      readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
-      readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
-    }>;
+  readonly repo: Schema.brand<Schema.TemplateLiteral<readonly ["repo_", Schema.String]>, "RepoId">;
+  readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
+  readonly project: Schema.brand<Schema.TemplateLiteral<readonly ["project_", Schema.String]>, "ProjectId">;
+  readonly scope: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"project">;
+    readonly name: Schema.brand<Schema.String, "ProjectName">;
   }>, Schema.Struct<{
-    readonly workflow: Schema.Struct<{
-      readonly name: Schema.brand<Schema.String, "WorkflowName">;
-      readonly run: Schema.brand<Schema.TemplateLiteral<readonly ["workflowrun_", Schema.String]>, "WorkflowRunId">;
-      readonly version: Schema.brand<Schema.String, "WorkflowVersion">;
-      readonly step: Schema.Struct<{
-        readonly name: Schema.String;
-        readonly count: Schema.Int;
-        readonly attempt: Schema.Int;
-      }>;
-    }>;
+    readonly kind: Schema.Literal<"owner">;
   }>]>;
-  readonly openedAt: Schema.DateTimeUtcFromMillis;
-  readonly closedAt: Schema.NullOr<Schema.DateTimeUtcFromMillis>;
-  readonly closedWhy: Schema.NullOr<Schema.Literals<readonly ["closed", "thread closed", "fork deleted"]>>;
-  readonly repair: Schema.Boolean;
-  readonly current: Schema.Struct<{
-    readonly version: Schema.brand<Schema.Int, "VersionNumber">;
-    readonly head: Schema.brand<Schema.String, "CommitOid">;
-    readonly base: Schema.NullOr<Schema.brand<Schema.String, "CommitOid">>;
-    readonly planVersion: Schema.NullOr<Schema.Int>;
-    readonly intentRevision: Schema.Int;
-    readonly generation: Schema.Int;
-    readonly state: Schema.Literals<readonly ["preparing", "evaluating", "gating", "waiting", "queued", "publishing", "merged", "superseded", "stale", "conflicted"]>;
-    readonly why: Schema.Literals<readonly ["opened", "push", "head set", "main moved", ".ref0/ changed", "outcomes changed", "intent changed", "needs changed", "project gate changed"]>;
+  readonly name: Schema.brand<Schema.String, "RepoName">;
+  readonly visibility: Schema.Literals<readonly ["private", "internal", "public"]>;
+  readonly state: Schema.Literals<readonly ["creating", "importing", "ready", "failed"]>;
+  readonly createdAt: Schema.DateTimeUtcFromMillis;
+}>>, Schema.toCodecJson<typeof RepoNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"list", "GET", "/v1/owners/:owner/repos", Schema.toCodecStringTree<Schema.Struct<{
+  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+  after: Schema.optionalKey<Schema.brand<Schema.String, "RepoName">>;
+  limit: Schema.optionalKey<Schema.Int>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+  readonly repos: Schema.$Array<Schema.Struct<{
+    readonly repo: Schema.brand<Schema.TemplateLiteral<readonly ["repo_", Schema.String]>, "RepoId">;
+    readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
+    readonly project: Schema.brand<Schema.TemplateLiteral<readonly ["project_", Schema.String]>, "ProjectId">;
+    readonly scope: Schema.Union<readonly [Schema.Struct<{
+      readonly kind: Schema.Literal<"project">;
+      readonly name: Schema.brand<Schema.String, "ProjectName">;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"owner">;
+    }>]>;
+    readonly name: Schema.brand<Schema.String, "RepoName">;
+    readonly visibility: Schema.Literals<readonly ["private", "internal", "public"]>;
+    readonly state: Schema.Literals<readonly ["creating", "importing", "ready", "failed"]>;
     readonly createdAt: Schema.DateTimeUtcFromMillis;
-  }>;
-  readonly threadNumber: Schema.Int;
-}>>, Schema.toCodecJson<typeof PullRequestNotFound | typeof RepoNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"gate", "GET", "/v1/repos/:owner/:repo/pulls/:pullRequest/gate", Schema.toCodecStringTree<Schema.Struct<{
+  }>>;
+  readonly nextAfter: Schema.optionalKey<Schema.brand<Schema.String, "RepoName">>;
+}>>, never, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"gate", "GET", "/v1/repos/:owner/:repo/pulls/:pullRequest/gate", Schema.toCodecStringTree<Schema.Struct<{
   owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
   repo: Schema.brand<Schema.String, "RepoName">;
   pullRequest: Schema.brand<Schema.Int, "PullRequestNumber">;
@@ -13269,6 +13456,7 @@ declare const ReposGroup_base: HttpApiGroup.HttpApiGroup<"repos", HttpApiEndpoin
         readonly permission: Schema.brand<Schema.String, "RepoPermissionName">;
       }>]>;
       readonly state: Schema.Literals<readonly ["asked", "yes", "no", "expired", "refused", "revoked"]>;
+      readonly why: Schema.optionalKey<Schema.Literals<readonly ["target", "self"]>>;
       readonly asked: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">>;
       readonly by: Schema.optionalKey<Schema.brand<Schema.String, "OwnerName">>;
       readonly at: Schema.optionalKey<Schema.DateTimeUtcFromMillis>;
@@ -13292,50 +13480,138 @@ declare const ReposGroup_base: HttpApiGroup.HttpApiGroup<"repos", HttpApiEndpoin
     readonly failed: Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">;
     readonly at: Schema.DateTimeUtcFromMillis;
   }>]>>>;
-}>>, Schema.toCodecJson<typeof PullRequestNotFound | typeof RepoNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"addNeed", "POST", "/v1/repos/:owner/:repo/pulls/:pullRequest/needs", Schema.toCodecStringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof PullRequestNotFound | typeof RepoNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"manifest", "GET", "/v1/repos/:owner/:repo/history/manifest", Schema.toCodecStringTree<Schema.Struct<{
   owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
   repo: Schema.brand<Schema.String, "RepoName">;
-  pullRequest: Schema.brand<Schema.Int, "PullRequestNumber">;
-}>>, never, Schema.toCodecJson<Schema.Struct<{
-  readonly need: Schema.Union<readonly [Schema.Struct<{
-    readonly kind: Schema.Literal<"checks">;
-  }>, Schema.Struct<{
-    readonly kind: Schema.Literal<"check">;
-    readonly name: Schema.brand<Schema.String, "CheckName">;
-    readonly params: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-    readonly source: Schema.optionalKey<Schema.Literal<"project">>;
-    readonly local: Schema.optionalKey<Schema.Literal<true>>;
-    readonly passkey: Schema.optionalKey<Schema.Struct<{
-      readonly from: Schema.Union<readonly [Schema.Literal<"accountable">, Schema.Struct<{
-        readonly person: Schema.brand<Schema.String, "OwnerName">;
-      }>, Schema.Struct<{
-        readonly permission: Schema.brand<Schema.String, "RepoPermissionName">;
-      }>]>;
+}>>, never, never, never, Schema.toCodecJson<Schema.Struct<{
+  readonly repo: Schema.brand<Schema.TemplateLiteral<readonly ["repo_", Schema.String]>, "RepoId">;
+  readonly version: Schema.Int;
+  readonly baseline: Schema.Struct<{
+    readonly gitRepository: Schema.brand<Schema.TemplateLiteral<readonly ["gitrepo_", Schema.String]>, "GitRepositoryId">;
+    readonly tip: Schema.brand<Schema.String, "CommitOid">;
+    readonly sequence: Schema.Int;
+    readonly depth: Schema.Int;
+    readonly boundary: Schema.$Array<Schema.brand<Schema.String, "CommitOid">>;
+  }>;
+  readonly main: Schema.optionalKey<Schema.Struct<{
+    readonly sequence: Schema.Int;
+    readonly commit: Schema.brand<Schema.String, "CommitOid">;
+  }>>;
+  readonly packs: Schema.$Array<Schema.Struct<{
+    readonly kind: Schema.Literals<readonly ["base", "baseline", "deepen", "merge", "rollup"]>;
+    readonly key: Schema.String;
+    readonly sha256: Schema.String;
+    readonly bytes: Schema.Int;
+    readonly merges: Schema.optionalKey<Schema.Struct<{
+      readonly first: Schema.Int;
+      readonly last: Schema.Int;
     }>>;
+    readonly baseline: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["gitrepo_", Schema.String]>, "GitRepositoryId">>;
+    readonly depth: Schema.optionalKey<Schema.Int>;
+    readonly roots: Schema.$Array<Schema.Struct<{
+      readonly commit: Schema.brand<Schema.String, "CommitOid">;
+      readonly parents: Schema.$Array<Schema.brand<Schema.String, "CommitOid">>;
+    }>>;
+  }>>;
+}>>, Schema.toCodecJson<typeof RepoNotFound | typeof HistoryNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"mirror", "GET", "/v1/repos/:owner/:repo/mirror", Schema.toCodecStringTree<Schema.Struct<{
+  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
+  repo: Schema.brand<Schema.String, "RepoName">;
+}>>, never, never, never, Schema.toCodecJson<Schema.Union<readonly [Schema.Struct<{
+  readonly kind: Schema.Literal<"none">;
+}>, Schema.Struct<{
+  readonly kind: Schema.Literal<"github">;
+  readonly branch: Schema.String;
+  readonly mirror: Schema.Union<readonly [Schema.Struct<{
+    readonly state: Schema.Literal<"on">;
   }>, Schema.Struct<{
-    readonly kind: Schema.Literal<"review">;
-  }>, Schema.Struct<{
-    readonly kind: Schema.Literal<"accountable">;
-  }>, Schema.Struct<{
-    readonly kind: Schema.Literal<"admin">;
+    readonly state: Schema.Literal<"paused">;
+    readonly paused: Schema.Union<readonly [Schema.Struct<{
+      readonly why: Schema.Literal<"diverged">;
+      readonly github: Schema.NullOr<Schema.brand<Schema.String, "CommitOid">>;
+    }>, Schema.Struct<{
+      readonly why: Schema.Literal<"refused">;
+      readonly said: Schema.String;
+    }>, Schema.Struct<{
+      readonly why: Schema.Literal<"unauthorized">;
+    }>]>;
   }>, Schema.Struct<{
-    readonly kind: Schema.Literal<"permission">;
-    readonly name: Schema.brand<Schema.String, "RepoPermissionName">;
+    readonly state: Schema.Literal<"off">;
   }>]>;
+  readonly lastMirrored: Schema.NullOr<Schema.brand<Schema.String, "CommitOid">>;
+  readonly nextStep: Schema.optionalKey<Schema.String>;
+}>]>>, Schema.toCodecJson<typeof RepoNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"create", "POST", "/v1/owners/:owner/repos", Schema.toCodecStringTree<Schema.Struct<{
+  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+  readonly name: Schema.brand<Schema.String, "RepoName">;
+  readonly project: Schema.optionalKey<Schema.brand<Schema.String, "ProjectName">>;
 }>>, Schema.toCodecStringTree<Schema.Struct<{
   'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
 }>>, Schema.toCodecJson<Schema.Struct<{
-  readonly pullRequest: Schema.optionalKey<Schema.brand<Schema.Int, "PullRequestNumber">>;
-  readonly outcome: Schema.Literals<readonly ["added", "removed", "unchanged"]>;
-  readonly version: Schema.optionalKey<Schema.brand<Schema.Int, "VersionNumber">>;
-  readonly source: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["needsource_", Schema.String]>, "NeedSourceId">>;
-  readonly removed: Schema.optionalKey<Schema.$Array<Schema.brand<Schema.TemplateLiteral<readonly ["needsource_", Schema.String]>, "NeedSourceId">>>;
-}>>, Schema.toCodecJson<typeof ProjectNotFound | typeof NotPermitted | typeof PullRequestNotFound | typeof ProjectNotReady | typeof RepoNotFound | typeof NeedRefused>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"removeNeeds", "POST", "/v1/repos/:owner/:repo/pulls/:pullRequest/needs/remove", Schema.toCodecStringTree<Schema.Struct<{
-  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
-  repo: Schema.brand<Schema.String, "RepoName">;
+  readonly repo: Schema.brand<Schema.TemplateLiteral<readonly ["repo_", Schema.String]>, "RepoId">;
+  readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
+  readonly project: Schema.brand<Schema.TemplateLiteral<readonly ["project_", Schema.String]>, "ProjectId">;
+  readonly scope: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"project">;
+    readonly name: Schema.brand<Schema.String, "ProjectName">;
+  }>, Schema.Struct<{
+    readonly kind: Schema.Literal<"owner">;
+  }>]>;
+  readonly name: Schema.brand<Schema.String, "RepoName">;
+  readonly visibility: Schema.Literals<readonly ["private", "internal", "public"]>;
+  readonly state: Schema.Literals<readonly ["creating", "importing", "ready", "failed"]>;
+  readonly createdAt: Schema.DateTimeUtcFromMillis;
+}>>, Schema.toCodecJson<typeof NameTaken | typeof NameReserved | typeof ProjectNotFound | typeof NotPermitted | typeof AuthorityUnavailable | typeof DeliveryOutsideWindow | typeof CommandRefused | typeof ApprovalNeeded | typeof SlowDown>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"import", "POST", "/v1/owners/:owner/repos/import", Schema.toCodecStringTree<Schema.Struct<{
+  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+  readonly name: Schema.brand<Schema.String, "RepoName">;
+  readonly project: Schema.optionalKey<Schema.brand<Schema.String, "ProjectName">>;
+  readonly url: Schema.brand<Schema.String, "RepoUrl">;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+  'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
+}>>, Schema.toCodecJson<Schema.Struct<{
+  readonly repo: Schema.brand<Schema.TemplateLiteral<readonly ["repo_", Schema.String]>, "RepoId">;
+  readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
+  readonly project: Schema.brand<Schema.TemplateLiteral<readonly ["project_", Schema.String]>, "ProjectId">;
+  readonly scope: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"project">;
+    readonly name: Schema.brand<Schema.String, "ProjectName">;
+  }>, Schema.Struct<{
+    readonly kind: Schema.Literal<"owner">;
+  }>]>;
+  readonly name: Schema.brand<Schema.String, "RepoName">;
+  readonly visibility: Schema.Literals<readonly ["private", "internal", "public"]>;
+  readonly state: Schema.Literals<readonly ["creating", "importing", "ready", "failed"]>;
+  readonly createdAt: Schema.DateTimeUtcFromMillis;
+}>>, Schema.toCodecJson<typeof NameTaken | typeof NameReserved | typeof ProjectNotFound | typeof NotPermitted | typeof AuthorityUnavailable | typeof DeliveryOutsideWindow | typeof CommandRefused | typeof ApprovalNeeded | typeof SlowDown>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"addNeed", "POST", "/v1/repos/:owner/:repo/pulls/:pullRequest/needs", Schema.toCodecStringTree<Schema.Struct<{
+  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
+  repo: Schema.brand<Schema.String, "RepoName">;
   pullRequest: Schema.brand<Schema.Int, "PullRequestNumber">;
 }>>, never, Schema.toCodecJson<Schema.Struct<{
-  readonly sources: Schema.$Array<Schema.brand<Schema.TemplateLiteral<readonly ["needsource_", Schema.String]>, "NeedSourceId">>;
+  readonly need: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"checks">;
+  }>, Schema.Struct<{
+    readonly kind: Schema.Literal<"check">;
+    readonly name: Schema.brand<Schema.String, "CheckName">;
+    readonly params: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    readonly source: Schema.optionalKey<Schema.Literal<"project">>;
+    readonly local: Schema.optionalKey<Schema.Literal<true>>;
+    readonly passkey: Schema.optionalKey<Schema.Struct<{
+      readonly from: Schema.Union<readonly [Schema.Literal<"accountable">, Schema.Struct<{
+        readonly person: Schema.brand<Schema.String, "OwnerName">;
+      }>, Schema.Struct<{
+        readonly permission: Schema.brand<Schema.String, "RepoPermissionName">;
+      }>]>;
+    }>>;
+  }>, Schema.Struct<{
+    readonly kind: Schema.Literal<"review">;
+  }>, Schema.Struct<{
+    readonly kind: Schema.Literal<"accountable">;
+  }>, Schema.Struct<{
+    readonly kind: Schema.Literal<"admin">;
+  }>, Schema.Struct<{
+    readonly kind: Schema.Literal<"permission">;
+    readonly name: Schema.brand<Schema.String, "RepoPermissionName">;
+  }>]>;
 }>>, Schema.toCodecStringTree<Schema.Struct<{
   'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
 }>>, Schema.toCodecJson<Schema.Struct<{
@@ -13344,55 +13620,21 @@ declare const ReposGroup_base: HttpApiGroup.HttpApiGroup<"repos", HttpApiEndpoin
   readonly version: Schema.optionalKey<Schema.brand<Schema.Int, "VersionNumber">>;
   readonly source: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["needsource_", Schema.String]>, "NeedSourceId">>;
   readonly removed: Schema.optionalKey<Schema.$Array<Schema.brand<Schema.TemplateLiteral<readonly ["needsource_", Schema.String]>, "NeedSourceId">>>;
-}>>, Schema.toCodecJson<typeof ProjectNotFound | typeof NotPermitted | typeof PullRequestNotFound | typeof ProjectNotReady | typeof RepoNotFound | typeof NeedRefused>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"projectGate", "GET", "/v1/repos/:owner/:repo/project-gate", Schema.toCodecStringTree<Schema.Struct<{
-  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
-  repo: Schema.brand<Schema.String, "RepoName">;
-}>>, never, never, never, Schema.toCodecJson<Schema.Struct<{
-  readonly active: Schema.Struct<{
-    readonly revision: Schema.Int;
-    readonly commit: Schema.NullOr<Schema.brand<Schema.String, "CommitOid">>;
-    readonly repo: Schema.NullOr<Schema.brand<Schema.TemplateLiteral<readonly ["repo_", Schema.String]>, "RepoId">>;
-  }>;
-  readonly pending: Schema.optionalKey<Schema.Struct<{
-    readonly revision: Schema.Int;
-    readonly commit: Schema.NullOr<Schema.brand<Schema.String, "CommitOid">>;
-    readonly repo: Schema.NullOr<Schema.brand<Schema.TemplateLiteral<readonly ["repo_", Schema.String]>, "RepoId">>;
-  }>>;
-  readonly holding: Schema.$Array<Schema.Struct<{
-    readonly repo: Schema.brand<Schema.TemplateLiteral<readonly ["repo_", Schema.String]>, "RepoId">;
-    readonly latch: Schema.brand<Schema.TemplateLiteral<readonly ["latch_", Schema.String]>, "LatchId">;
-    readonly thread: Schema.brand<Schema.TemplateLiteral<readonly ["thread_", Schema.String]>, "ThreadId">;
-    readonly version: Schema.brand<Schema.TemplateLiteral<readonly ["version_", Schema.String]>, "VersionId">;
-    readonly gate: Schema.Int;
-    readonly since: Schema.Int;
-  }>>;
-}>>, Schema.toCodecJson<typeof RepoNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"mirror", "GET", "/v1/repos/:owner/:repo/mirror", Schema.toCodecStringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof ProjectNotFound | typeof NotPermitted | typeof PullRequestNotFound | typeof ProjectNotReady | typeof RepoNotFound | typeof NeedRefused>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"removeNeeds", "POST", "/v1/repos/:owner/:repo/pulls/:pullRequest/needs/remove", Schema.toCodecStringTree<Schema.Struct<{
   owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
   repo: Schema.brand<Schema.String, "RepoName">;
-}>>, never, never, never, Schema.toCodecJson<Schema.Union<readonly [Schema.Struct<{
-  readonly kind: Schema.Literal<"none">;
-}>, Schema.Struct<{
-  readonly kind: Schema.Literal<"github">;
-  readonly branch: Schema.String;
-  readonly mirror: Schema.Union<readonly [Schema.Struct<{
-    readonly state: Schema.Literal<"on">;
-  }>, Schema.Struct<{
-    readonly state: Schema.Literal<"paused">;
-    readonly paused: Schema.Union<readonly [Schema.Struct<{
-      readonly why: Schema.Literal<"diverged">;
-      readonly github: Schema.NullOr<Schema.brand<Schema.String, "CommitOid">>;
-    }>, Schema.Struct<{
-      readonly why: Schema.Literal<"refused">;
-      readonly said: Schema.String;
-    }>, Schema.Struct<{
-      readonly why: Schema.Literal<"unauthorized">;
-    }>]>;
-  }>, Schema.Struct<{
-    readonly state: Schema.Literal<"off">;
-  }>]>;
-  readonly lastMirrored: Schema.NullOr<Schema.brand<Schema.String, "CommitOid">>;
-  readonly nextStep: Schema.optionalKey<Schema.String>;
-}>]>>, Schema.toCodecJson<typeof RepoNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"setMirror", "PUT", "/v1/repos/:owner/:repo/mirror", Schema.toCodecStringTree<Schema.Struct<{
+  pullRequest: Schema.brand<Schema.Int, "PullRequestNumber">;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+  readonly sources: Schema.$Array<Schema.brand<Schema.TemplateLiteral<readonly ["needsource_", Schema.String]>, "NeedSourceId">>;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+  'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
+}>>, Schema.toCodecJson<Schema.Struct<{
+  readonly pullRequest: Schema.optionalKey<Schema.brand<Schema.Int, "PullRequestNumber">>;
+  readonly outcome: Schema.Literals<readonly ["added", "removed", "unchanged"]>;
+  readonly version: Schema.optionalKey<Schema.brand<Schema.Int, "VersionNumber">>;
+  readonly source: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["needsource_", Schema.String]>, "NeedSourceId">>;
+  readonly removed: Schema.optionalKey<Schema.$Array<Schema.brand<Schema.TemplateLiteral<readonly ["needsource_", Schema.String]>, "NeedSourceId">>>;
+}>>, Schema.toCodecJson<typeof ProjectNotFound | typeof NotPermitted | typeof PullRequestNotFound | typeof ProjectNotReady | typeof RepoNotFound | typeof NeedRefused>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"setMirror", "PUT", "/v1/repos/:owner/:repo/mirror", Schema.toCodecStringTree<Schema.Struct<{
   owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
   repo: Schema.brand<Schema.String, "RepoName">;
 }>>, never, Schema.toCodecJson<Schema.Struct<{
@@ -13422,38 +13664,7 @@ declare const ReposGroup_base: HttpApiGroup.HttpApiGroup<"repos", HttpApiEndpoin
   }>]>;
   readonly lastMirrored: Schema.NullOr<Schema.brand<Schema.String, "CommitOid">>;
   readonly nextStep: Schema.optionalKey<Schema.String>;
-}>]>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof DeliveryOutsideWindow | typeof RepoNotFound | typeof CommandRefused | typeof ApprovalNeeded | typeof SlowDown | typeof NotMirrored>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"line", "GET", "/v1/repos/:owner/:repo/commits/:commit/lines", Schema.toCodecStringTree<Schema.Struct<{
-  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
-  repo: Schema.brand<Schema.String, "RepoName">;
-  commit: Schema.brand<Schema.String, "CommitOid">;
-}>>, Schema.toCodecStringTree<Schema.Struct<{
-  path: Schema.brand<Schema.String, "RepoPath">;
-  line: Schema.Int;
-}>>, never, never, Schema.toCodecJson<Schema.Struct<{
-  readonly commit: Schema.brand<Schema.String, "CommitOid">;
-  readonly path: Schema.brand<Schema.String, "RepoPath">;
-  readonly line: Schema.Int;
-  readonly from: Schema.Literals<readonly ["session", "workflow", "main", "unknown"]>;
-  readonly authorship: Schema.Literals<readonly ["ai", "human", "mixed", "unknown"]>;
-  readonly turns: Schema.$Array<Schema.Struct<{
-    readonly thread: Schema.brand<Schema.TemplateLiteral<readonly ["thread_", Schema.String]>, "ThreadId">;
-    readonly threadNumber: Schema.Int;
-    readonly session: Schema.brand<Schema.TemplateLiteral<readonly ["session_", Schema.String]>, "SessionId">;
-    readonly turn: Schema.Int;
-    readonly authorship: Schema.Literals<readonly ["ai", "human", "mixed", "unknown"]>;
-    readonly model: Schema.optionalKey<Schema.String>;
-  }>>;
-  readonly workflow: Schema.optionalKey<Schema.Struct<{
-    readonly name: Schema.brand<Schema.String, "WorkflowName">;
-    readonly run: Schema.brand<Schema.TemplateLiteral<readonly ["workflowrun_", Schema.String]>, "WorkflowRunId">;
-    readonly version: Schema.brand<Schema.String, "WorkflowVersion">;
-    readonly step: Schema.Struct<{
-      readonly name: Schema.String;
-      readonly count: Schema.Int;
-      readonly attempt: Schema.Int;
-    }>;
-  }>>;
-}>>, Schema.toCodecJson<typeof RepoNotFound>, Authorization, never>, false>;
+}>]>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof DeliveryOutsideWindow | typeof RepoNotFound | typeof CommandRefused | typeof ApprovalNeeded | typeof SlowDown | typeof NotMirrored>, Authorization, never>, false>;
 /**
  * An owner's repos, as each reader may see them: a repo shows only to whoever can see its
  * project. Adding one is a person's approved command, which reaches `/v1` with approvals.
@@ -17080,259 +17291,101 @@ declare const WorkflowsGroup_base: HttpApiGroup.HttpApiGroup<"workflows", HttpAp
  * person.
  */
 declare class WorkflowsGroup extends WorkflowsGroup_base {}
-declare const RunsGroup_base: HttpApiGroup.HttpApiGroup<"runs", HttpApiEndpoint.HttpApiEndpoint<"start", "POST", "/v1/repos/:owner/:repo/runs", Schema.toCodecStringTree<Schema.Struct<{
+declare const RunsGroup_base: HttpApiGroup.HttpApiGroup<"runs", HttpApiEndpoint.HttpApiEndpoint<"cancel", "POST", "/v1/repos/:owner/:repo/runs/waiting/:start/cancel", Schema.toCodecStringTree<Schema.Struct<{
+  start: Schema.brand<Schema.TemplateLiteral<readonly ["startwait_", Schema.String]>, "StartWaitId">;
   owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
   repo: Schema.brand<Schema.String, "RepoName">;
-}>>, never, Schema.toCodecJson<Schema.Struct<{
-  readonly check: Schema.brand<Schema.String, "CheckKey">;
-  readonly on: Schema.Union<readonly [Schema.Struct<{
-    readonly kind: Schema.Literal<"main">;
-  }>, Schema.Struct<{
-    readonly kind: Schema.Literal<"thread">;
-    readonly thread: Schema.brand<Schema.String, "WrittenThread">;
-    readonly branch: Schema.optionalKey<Schema.String>;
-  }>]>;
-  readonly params: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-  readonly rerun: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">>;
 }>>, Schema.toCodecStringTree<Schema.Struct<{
-  'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
-}>>, Schema.toCodecJson<Schema.Union<readonly [Schema.Struct<{
+  readonly thread: Schema.optionalKey<Schema.brand<Schema.String, "WrittenThread">>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+  readonly cancelled: Schema.Literals<readonly ["start", "yours"]>;
+}>>, Schema.toCodecJson<typeof NotPermitted | typeof ThreadNotFound | typeof RepoNotFound | typeof StartNotFound | typeof StartPast | typeof RunUnavailable>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"list", "GET", "/v1/repos/:owner/:repo/runs", Schema.toCodecStringTree<Schema.Struct<{
+  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
+  repo: Schema.brand<Schema.String, "RepoName">;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+  readonly thread: Schema.optionalKey<Schema.brand<Schema.String, "WrittenThread">>;
+  readonly check: Schema.optionalKey<Schema.brand<Schema.String, "CheckKey">>;
+  readonly before: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
   readonly runs: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
     readonly run: Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">;
+    readonly check: Schema.brand<Schema.String, "CheckName">;
     readonly params: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
     readonly rerun: Schema.Int;
     readonly rerunOf: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">>;
-    readonly got: Schema.Literals<readonly ["new", "joined", "answered"]>;
-    readonly reusedFrom: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">>;
-    readonly readsMoved: Schema.optionalKey<Schema.String>;
-    readonly reuseSkipped: Schema.optionalKey<Schema.String>;
+    readonly tree: Schema.brand<Schema.String, "TreeOid">;
+    readonly origin: Schema.Literals<readonly ["main", "thread", "project"]>;
+    readonly createdAt: Schema.DateTimeUtcFromMillis;
+    readonly startedAt: Schema.optionalKey<Schema.DateTimeUtcFromMillis>;
+    readonly endedAt: Schema.optionalKey<Schema.DateTimeUtcFromMillis>;
+    readonly starters: Schema.$Array<Schema.Struct<{
+      readonly actor: Schema.Union<readonly [Schema.Struct<{
+        readonly kind: Schema.Literal<"person">;
+        readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">;
+      }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"agent">;
+        readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
+        readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
+      }>, Schema.Struct<{
+        readonly kind: Schema.Literal<"ref0">;
+        readonly id: Schema.Literals<("ref0:attachments" | "ref0:barrier" | "ref0:blockers" | "ref0:checks" | "ref0:gate" | "ref0:hooks" | "ref0:importer" | "ref0:invitations" | "ref0:listings" | "ref0:mirror" | "ref0:needs" | "ref0:oauth" | "ref0:owners" | "ref0:plans" | "ref0:prepare" | "ref0:project-gate" | "ref0:pushes" | "ref0:queue" | "ref0:rebuilder" | "ref0:sessions" | "ref0:sign-in" | "ref0:stages" | "ref0:sweeper" | "ref0:usage" | "ref0:warm-up" | "ref0:workflows")[]>;
+      }>]>;
+      readonly request: Schema.String;
+      readonly at: Schema.DateTimeUtcFromMillis;
+    }>>;
+    readonly local: Schema.optionalKey<Schema.Struct<{
+      readonly attachment: Schema.Struct<{
+        readonly person: Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">;
+        readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["token_", Schema.String]>, "TokenId">;
+      }>;
+      readonly agent: Schema.optionalKey<Schema.Struct<{
+        readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
+        readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
+      }>>;
+    }>>;
+    readonly routes: Schema.optionalKey<Schema.Struct<{
+      readonly requests: Schema.Int;
+      readonly omitted: Schema.Int;
+      readonly trace: Schema.Literals<readonly ["pending", "kept", "failed"]>;
+      readonly refusals: Schema.$Array<Schema.Struct<{
+        readonly run: Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">;
+        readonly step: Schema.String;
+        readonly count: Schema.Int;
+        readonly attempt: Schema.Int;
+        readonly provenance: Schema.Literals<readonly ["observed", "reported"]>;
+        readonly why: Schema.Literals<readonly ["scheme", "https", "host", "port", "websocket", "webrtc", "deadline", "ended", "not yours", "closed", "browse closed", "fenced", "not open", "not served", "stopped", "unreachable", "too many", "unavailable"]>;
+        readonly recovery: Schema.String;
+        readonly session: Schema.brand<Schema.TemplateLiteral<readonly ["sbxsession_", Schema.String]>, "SandboxSessionId">;
+        readonly url: Schema.String;
+      }>>;
+      readonly refusalsOmitted: Schema.Int;
+      readonly reported: Schema.$Array<Schema.Struct<{
+        readonly run: Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">;
+        readonly step: Schema.String;
+        readonly count: Schema.Int;
+        readonly attempt: Schema.Int;
+        readonly provenance: Schema.Literals<readonly ["observed", "reported"]>;
+        readonly why: Schema.Literals<readonly ["scheme", "https", "host", "port", "websocket", "webrtc", "deadline", "ended", "not yours", "closed", "browse closed", "fenced", "not open", "not served", "stopped", "unreachable", "too many", "unavailable"]>;
+        readonly recovery: Schema.String;
+        readonly session: Schema.brand<Schema.TemplateLiteral<readonly ["sbxsession_", Schema.String]>, "SandboxSessionId">;
+        readonly url: Schema.String;
+      }>>;
+      readonly reportedOmitted: Schema.Int;
+    }>>;
+    readonly browsers: Schema.optionalKey<Schema.Struct<{
+      readonly browses: Schema.Int;
+      readonly closing: Schema.Int;
+      readonly unconfirmed: Schema.Int;
+      readonly lastError: Schema.optionalKey<Schema.String>;
+      readonly unresolved: Schema.Int;
+      readonly presumedExpired: Schema.Int;
+      readonly browserMs: Schema.Int;
+      readonly estimated: Schema.Boolean;
+    }>>;
     readonly state: Schema.Literals<readonly ["waiting", "pending", "starting", "created", "running"]>;
   }>, Schema.Struct<{
     readonly run: Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">;
-    readonly params: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
-    readonly rerun: Schema.Int;
-    readonly rerunOf: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">>;
-    readonly got: Schema.Literals<readonly ["new", "joined", "answered"]>;
-    readonly reusedFrom: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">>;
-    readonly readsMoved: Schema.optionalKey<Schema.String>;
-    readonly reuseSkipped: Schema.optionalKey<Schema.String>;
-    readonly state: Schema.Literal<"ended">;
-    readonly conclusion: Schema.Literals<readonly ["success", "failure", "neutral"]>;
-    readonly reused: Schema.optionalKey<Schema.Literal<true>>;
-  }>, Schema.Struct<{
-    readonly run: Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">;
-    readonly params: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
-    readonly rerun: Schema.Int;
-    readonly rerunOf: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">>;
-    readonly got: Schema.Literals<readonly ["new", "joined", "answered"]>;
-    readonly reusedFrom: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">>;
-    readonly readsMoved: Schema.optionalKey<Schema.String>;
-    readonly reuseSkipped: Schema.optionalKey<Schema.String>;
-    readonly state: Schema.Literal<"ended">;
-    readonly error: Schema.Literals<readonly ["timeout", "threw", "invalid output", "unavailable", "expired", "cancelled"]>;
-  }>]>>;
-}>, Schema.Struct<{
-  readonly waiting: Schema.Struct<{
-    readonly start: Schema.brand<Schema.TemplateLiteral<readonly ["startwait_", Schema.String]>, "StartWaitId">;
-    readonly check: Schema.brand<Schema.String, "CheckName">;
-    readonly params: Schema.$Array<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-    readonly thread: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["thread_", Schema.String]>, "ThreadId">>;
-    readonly waitingSince: Schema.DateTimeUtcFromString;
-    readonly endsAt: Schema.DateTimeUtcFromString;
-    readonly runs: Schema.$Array<Schema.Struct<{
-      readonly workflow: Schema.brand<Schema.String, "WorkflowName">;
-      readonly run: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["workflowrun_", Schema.String]>, "WorkflowRunId">>;
-      readonly title: Schema.optionalKey<Schema.String>;
-      readonly state: Schema.Literals<readonly ["starting", "going", "allowed", "refused", "failed"]>;
-      readonly leaves: Schema.$Array<Schema.Struct<{
-        readonly kind: Schema.Literals<readonly ["ask", "passkey"]>;
-        readonly state: Schema.Literals<readonly ["waiting", "answered", "ended"]>;
-        readonly since: Schema.DateTimeUtcFromString;
-        readonly who: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
-          readonly kind: Schema.Literal<"person">;
-          readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">;
-          readonly name: Schema.optionalKey<Schema.brand<Schema.String, "OwnerName">>;
-        }>, Schema.Struct<{
-          readonly kind: Schema.Literal<"agent">;
-          readonly handle: Schema.brand<Schema.String, "AgentHandle">;
-        }>, Schema.Struct<{
-          readonly kind: Schema.Literal<"holders">;
-          readonly permission: Schema.String;
-        }>]>>;
-        readonly what: Schema.optionalKey<Schema.String>;
-        readonly answer: Schema.optionalKey<Schema.String>;
-      }>>;
-    }>>;
-  }>;
-}>]>>, Schema.toCodecJson<typeof NotPermitted | typeof ThreadNotFound | typeof RepoNotFound | typeof RequestChanged | typeof RunsBusy | typeof RunRefused | typeof RunUnavailable | typeof CheckNotFound | typeof NoThreadHead>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"waiting", "GET", "/v1/repos/:owner/:repo/runs/waiting/:start", Schema.toCodecStringTree<Schema.Struct<{
-  start: Schema.brand<Schema.TemplateLiteral<readonly ["startwait_", Schema.String]>, "StartWaitId">;
-  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
-  repo: Schema.brand<Schema.String, "RepoName">;
-}>>, Schema.toCodecStringTree<Schema.Struct<{
-  readonly thread: Schema.optionalKey<Schema.brand<Schema.String, "WrittenThread">>;
-}>>, never, never, Schema.toCodecJson<Schema.Union<readonly [Schema.Struct<{
-  readonly runs: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-    readonly run: Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">;
-    readonly params: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
-    readonly rerun: Schema.Int;
-    readonly rerunOf: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">>;
-    readonly got: Schema.Literals<readonly ["new", "joined", "answered"]>;
-    readonly reusedFrom: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">>;
-    readonly readsMoved: Schema.optionalKey<Schema.String>;
-    readonly reuseSkipped: Schema.optionalKey<Schema.String>;
-    readonly state: Schema.Literals<readonly ["waiting", "pending", "starting", "created", "running"]>;
-  }>, Schema.Struct<{
-    readonly run: Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">;
-    readonly params: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
-    readonly rerun: Schema.Int;
-    readonly rerunOf: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">>;
-    readonly got: Schema.Literals<readonly ["new", "joined", "answered"]>;
-    readonly reusedFrom: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">>;
-    readonly readsMoved: Schema.optionalKey<Schema.String>;
-    readonly reuseSkipped: Schema.optionalKey<Schema.String>;
-    readonly state: Schema.Literal<"ended">;
-    readonly conclusion: Schema.Literals<readonly ["success", "failure", "neutral"]>;
-    readonly reused: Schema.optionalKey<Schema.Literal<true>>;
-  }>, Schema.Struct<{
-    readonly run: Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">;
-    readonly params: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
-    readonly rerun: Schema.Int;
-    readonly rerunOf: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">>;
-    readonly got: Schema.Literals<readonly ["new", "joined", "answered"]>;
-    readonly reusedFrom: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">>;
-    readonly readsMoved: Schema.optionalKey<Schema.String>;
-    readonly reuseSkipped: Schema.optionalKey<Schema.String>;
-    readonly state: Schema.Literal<"ended">;
-    readonly error: Schema.Literals<readonly ["timeout", "threw", "invalid output", "unavailable", "expired", "cancelled"]>;
-  }>]>>;
-}>, Schema.Struct<{
-  readonly waiting: Schema.Struct<{
-    readonly start: Schema.brand<Schema.TemplateLiteral<readonly ["startwait_", Schema.String]>, "StartWaitId">;
-    readonly check: Schema.brand<Schema.String, "CheckName">;
-    readonly params: Schema.$Array<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
-    readonly thread: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["thread_", Schema.String]>, "ThreadId">>;
-    readonly waitingSince: Schema.DateTimeUtcFromString;
-    readonly endsAt: Schema.DateTimeUtcFromString;
-    readonly runs: Schema.$Array<Schema.Struct<{
-      readonly workflow: Schema.brand<Schema.String, "WorkflowName">;
-      readonly run: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["workflowrun_", Schema.String]>, "WorkflowRunId">>;
-      readonly title: Schema.optionalKey<Schema.String>;
-      readonly state: Schema.Literals<readonly ["starting", "going", "allowed", "refused", "failed"]>;
-      readonly leaves: Schema.$Array<Schema.Struct<{
-        readonly kind: Schema.Literals<readonly ["ask", "passkey"]>;
-        readonly state: Schema.Literals<readonly ["waiting", "answered", "ended"]>;
-        readonly since: Schema.DateTimeUtcFromString;
-        readonly who: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
-          readonly kind: Schema.Literal<"person">;
-          readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">;
-          readonly name: Schema.optionalKey<Schema.brand<Schema.String, "OwnerName">>;
-        }>, Schema.Struct<{
-          readonly kind: Schema.Literal<"agent">;
-          readonly handle: Schema.brand<Schema.String, "AgentHandle">;
-        }>, Schema.Struct<{
-          readonly kind: Schema.Literal<"holders">;
-          readonly permission: Schema.String;
-        }>]>>;
-        readonly what: Schema.optionalKey<Schema.String>;
-        readonly answer: Schema.optionalKey<Schema.String>;
-      }>>;
-    }>>;
-  }>;
-}>]>>, Schema.toCodecJson<typeof NotPermitted | typeof ThreadNotFound | typeof RepoNotFound | typeof RequestChanged | typeof RunsBusy | typeof RunRefused | typeof StartNotFound | typeof RunUnavailable>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"cancel", "POST", "/v1/repos/:owner/:repo/runs/waiting/:start/cancel", Schema.toCodecStringTree<Schema.Struct<{
-  start: Schema.brand<Schema.TemplateLiteral<readonly ["startwait_", Schema.String]>, "StartWaitId">;
-  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
-  repo: Schema.brand<Schema.String, "RepoName">;
-}>>, Schema.toCodecStringTree<Schema.Struct<{
-  readonly thread: Schema.optionalKey<Schema.brand<Schema.String, "WrittenThread">>;
-}>>, never, never, Schema.toCodecJson<Schema.Struct<{
-  readonly cancelled: Schema.Literals<readonly ["start", "yours"]>;
-}>>, Schema.toCodecJson<typeof NotPermitted | typeof ThreadNotFound | typeof RepoNotFound | typeof StartNotFound | typeof StartPast | typeof RunUnavailable>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"list", "GET", "/v1/repos/:owner/:repo/runs", Schema.toCodecStringTree<Schema.Struct<{
-  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
-  repo: Schema.brand<Schema.String, "RepoName">;
-}>>, Schema.toCodecStringTree<Schema.Struct<{
-  readonly thread: Schema.optionalKey<Schema.brand<Schema.String, "WrittenThread">>;
-  readonly check: Schema.optionalKey<Schema.brand<Schema.String, "CheckKey">>;
-  readonly before: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">>;
-}>>, never, never, Schema.toCodecJson<Schema.Struct<{
-  readonly runs: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
-    readonly run: Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">;
-    readonly check: Schema.brand<Schema.String, "CheckName">;
-    readonly params: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
-    readonly rerun: Schema.Int;
-    readonly rerunOf: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">>;
-    readonly tree: Schema.brand<Schema.String, "TreeOid">;
-    readonly origin: Schema.Literals<readonly ["main", "thread", "project"]>;
-    readonly createdAt: Schema.DateTimeUtcFromMillis;
-    readonly startedAt: Schema.optionalKey<Schema.DateTimeUtcFromMillis>;
-    readonly endedAt: Schema.optionalKey<Schema.DateTimeUtcFromMillis>;
-    readonly starters: Schema.$Array<Schema.Struct<{
-      readonly actor: Schema.Union<readonly [Schema.Struct<{
-        readonly kind: Schema.Literal<"person">;
-        readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">;
-      }>, Schema.Struct<{
-        readonly kind: Schema.Literal<"agent">;
-        readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
-        readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
-      }>, Schema.Struct<{
-        readonly kind: Schema.Literal<"ref0">;
-        readonly id: Schema.Literals<("ref0:attachments" | "ref0:barrier" | "ref0:blockers" | "ref0:checks" | "ref0:gate" | "ref0:hooks" | "ref0:importer" | "ref0:invitations" | "ref0:listings" | "ref0:mirror" | "ref0:needs" | "ref0:oauth" | "ref0:owners" | "ref0:plans" | "ref0:prepare" | "ref0:project-gate" | "ref0:pushes" | "ref0:queue" | "ref0:rebuilder" | "ref0:sessions" | "ref0:sign-in" | "ref0:stages" | "ref0:sweeper" | "ref0:usage" | "ref0:warm-up" | "ref0:workflows")[]>;
-      }>]>;
-      readonly request: Schema.String;
-      readonly at: Schema.DateTimeUtcFromMillis;
-    }>>;
-    readonly local: Schema.optionalKey<Schema.Struct<{
-      readonly attachment: Schema.Struct<{
-        readonly person: Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">;
-        readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["token_", Schema.String]>, "TokenId">;
-      }>;
-      readonly agent: Schema.optionalKey<Schema.Struct<{
-        readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
-        readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
-      }>>;
-    }>>;
-    readonly routes: Schema.optionalKey<Schema.Struct<{
-      readonly requests: Schema.Int;
-      readonly omitted: Schema.Int;
-      readonly trace: Schema.Literals<readonly ["pending", "kept", "failed"]>;
-      readonly refusals: Schema.$Array<Schema.Struct<{
-        readonly run: Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">;
-        readonly step: Schema.String;
-        readonly count: Schema.Int;
-        readonly attempt: Schema.Int;
-        readonly provenance: Schema.Literals<readonly ["observed", "reported"]>;
-        readonly why: Schema.Literals<readonly ["scheme", "https", "host", "port", "websocket", "webrtc", "deadline", "ended", "not yours", "closed", "browse closed", "fenced", "not open", "not served", "stopped", "unreachable", "too many", "unavailable"]>;
-        readonly recovery: Schema.String;
-        readonly session: Schema.brand<Schema.TemplateLiteral<readonly ["sbxsession_", Schema.String]>, "SandboxSessionId">;
-        readonly url: Schema.String;
-      }>>;
-      readonly refusalsOmitted: Schema.Int;
-      readonly reported: Schema.$Array<Schema.Struct<{
-        readonly run: Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">;
-        readonly step: Schema.String;
-        readonly count: Schema.Int;
-        readonly attempt: Schema.Int;
-        readonly provenance: Schema.Literals<readonly ["observed", "reported"]>;
-        readonly why: Schema.Literals<readonly ["scheme", "https", "host", "port", "websocket", "webrtc", "deadline", "ended", "not yours", "closed", "browse closed", "fenced", "not open", "not served", "stopped", "unreachable", "too many", "unavailable"]>;
-        readonly recovery: Schema.String;
-        readonly session: Schema.brand<Schema.TemplateLiteral<readonly ["sbxsession_", Schema.String]>, "SandboxSessionId">;
-        readonly url: Schema.String;
-      }>>;
-      readonly reportedOmitted: Schema.Int;
-    }>>;
-    readonly browsers: Schema.optionalKey<Schema.Struct<{
-      readonly browses: Schema.Int;
-      readonly closing: Schema.Int;
-      readonly unconfirmed: Schema.Int;
-      readonly lastError: Schema.optionalKey<Schema.String>;
-      readonly unresolved: Schema.Int;
-      readonly presumedExpired: Schema.Int;
-      readonly browserMs: Schema.Int;
-      readonly estimated: Schema.Boolean;
-    }>>;
-    readonly state: Schema.Literals<readonly ["waiting", "pending", "starting", "created", "running"]>;
-  }>, Schema.Struct<{
-    readonly run: Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">;
-    readonly check: Schema.brand<Schema.String, "CheckName">;
+    readonly check: Schema.brand<Schema.String, "CheckName">;
     readonly params: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
     readonly rerun: Schema.Int;
     readonly rerunOf: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">>;
@@ -17789,22 +17842,7 @@ declare const RunsGroup_base: HttpApiGroup.HttpApiGroup<"runs", HttpApiEndpoint.
     readonly state: Schema.Literal<"ended">;
     readonly error: Schema.Literals<readonly ["timeout", "threw", "invalid output", "unavailable", "expired", "cancelled"]>;
   }>]>;
-}>>, Schema.toCodecJson<typeof NotPermitted | typeof ThreadNotFound | typeof RepoNotFound | typeof RequestChanged | typeof RunsBusy | typeof RunUnavailable | typeof LocalRunRefused>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"restoreSigner", "POST", "/v1/repos/:owner/:repo/checks/signers/restore", Schema.toCodecStringTree<Schema.Struct<{
-  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
-  repo: Schema.brand<Schema.String, "RepoName">;
-}>>, never, Schema.toCodecJson<Schema.Union<readonly [Schema.Struct<{
-  readonly check: Schema.brand<Schema.String, "CheckKey">;
-  readonly attachment: Schema.brand<Schema.TemplateLiteral<readonly ["token_", Schema.String]>, "TokenId">;
-}>, Schema.Struct<{
-  readonly check: Schema.brand<Schema.String, "CheckKey">;
-  readonly person: Schema.brand<Schema.String, "OwnerName">;
-}>]>>, never, Schema.toCodecJson<Schema.Union<readonly [Schema.Struct<{
-  readonly check: Schema.brand<Schema.String, "CheckKey">;
-  readonly attachment: Schema.brand<Schema.TemplateLiteral<readonly ["token_", Schema.String]>, "TokenId">;
-}>, Schema.Struct<{
-  readonly check: Schema.brand<Schema.String, "CheckKey">;
-  readonly person: Schema.brand<Schema.String, "OwnerName">;
-}>]>>, Schema.toCodecJson<typeof NotPermitted | typeof RepoNotFound | typeof SignerNotRevoked>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"trace", "GET", "/v1/repos/:owner/:repo/runs/:run/trace", Schema.toCodecStringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof NotPermitted | typeof ThreadNotFound | typeof RepoNotFound | typeof RequestChanged | typeof RunsBusy | typeof RunUnavailable | typeof LocalRunRefused>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"trace", "GET", "/v1/repos/:owner/:repo/runs/:run/trace", Schema.toCodecStringTree<Schema.Struct<{
   owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
   repo: Schema.brand<Schema.String, "RepoName">;
   run: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">, Schema.brand<Schema.TemplateLiteral<readonly ["workflowrun_", Schema.String]>, "WorkflowRunId">]>;
@@ -17930,36 +17968,193 @@ declare const RunsGroup_base: HttpApiGroup.HttpApiGroup<"runs", HttpApiEndpoint.
   }>>;
   readonly cursor: Schema.brand<Schema.String, "TraceCursor">;
   readonly more: Schema.Boolean;
-}>>, Schema.toCodecJson<typeof ThreadNotFound | typeof RepoNotFound | typeof RunNotFound | typeof InvalidCursor | typeof TraceUnavailable>, Authorization, never>, false>;
-/**
- * A repo's check runs: starting them, on `main` or a thread's head, for whoever's token reaches
- * `check:run` there, and listing them, one scope at a time, for whoever sees it. A person's start
- * outside a session runs by their approval; an agent's from its session, by its own token. What
- * a local run of a check runs, and its report, of an identity an open version of a thread needs,
- * each by whoever may start runs on that thread, the report from the attachment it ran on; and an
- * admin's restore of a signer a miss revoked. And one run's trace, a check run's or a workflow
- * run's of the repo's project, a page at a time, for whoever sees the scope it was first started
- * in.
- */
-declare class RunsGroup extends RunsGroup_base {}
-declare const ClientGrantsGroup_base: HttpApiGroup.HttpApiGroup<"clientGrants", HttpApiEndpoint.HttpApiEndpoint<"grant", "POST", "/v1/owners/:owner/client-grants", Schema.toCodecStringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof ThreadNotFound | typeof RepoNotFound | typeof RunNotFound | typeof InvalidCursor | typeof TraceUnavailable>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"waiting", "GET", "/v1/repos/:owner/:repo/runs/waiting/:start", Schema.toCodecStringTree<Schema.Struct<{
+  start: Schema.brand<Schema.TemplateLiteral<readonly ["startwait_", Schema.String]>, "StartWaitId">;
   owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
-}>>, never, Schema.toCodecJson<Schema.Struct<{
-  readonly client: Schema.String;
-  readonly agent: Schema.brand<Schema.String, "AgentHandle">;
-  readonly create: Schema.optionalKey<Schema.Boolean>;
-  readonly access: Schema.Literals<readonly ["read", "act"]>;
-  readonly projects: Schema.NonEmptyArray<Schema.Struct<{
-    readonly owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
-    readonly project: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["project_", Schema.String]>, "ProjectId">, Schema.brand<Schema.String, "ProjectName">]>;
-  }>>;
+  repo: Schema.brand<Schema.String, "RepoName">;
 }>>, Schema.toCodecStringTree<Schema.Struct<{
-  'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
-}>>, Schema.toCodecJson<Schema.Struct<{
-  readonly grant: Schema.brand<Schema.TemplateLiteral<readonly ["token_", Schema.String]>, "TokenId">;
-  readonly client: Schema.String;
-}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof DeliveryOutsideWindow | typeof CommandRefused | typeof ApprovalNeeded | typeof SlowDown | typeof ConsentRefused>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"asked", "POST", "/v1/owners/:owner/client-grants/asked", Schema.toCodecStringTree<Schema.Struct<{
-  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
+  readonly thread: Schema.optionalKey<Schema.brand<Schema.String, "WrittenThread">>;
+}>>, never, never, Schema.toCodecJson<Schema.Union<readonly [Schema.Struct<{
+  readonly runs: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+    readonly run: Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">;
+    readonly params: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly rerun: Schema.Int;
+    readonly rerunOf: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">>;
+    readonly got: Schema.Literals<readonly ["new", "joined", "answered"]>;
+    readonly reusedFrom: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">>;
+    readonly readsMoved: Schema.optionalKey<Schema.String>;
+    readonly reuseSkipped: Schema.optionalKey<Schema.String>;
+    readonly state: Schema.Literals<readonly ["waiting", "pending", "starting", "created", "running"]>;
+  }>, Schema.Struct<{
+    readonly run: Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">;
+    readonly params: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly rerun: Schema.Int;
+    readonly rerunOf: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">>;
+    readonly got: Schema.Literals<readonly ["new", "joined", "answered"]>;
+    readonly reusedFrom: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">>;
+    readonly readsMoved: Schema.optionalKey<Schema.String>;
+    readonly reuseSkipped: Schema.optionalKey<Schema.String>;
+    readonly state: Schema.Literal<"ended">;
+    readonly conclusion: Schema.Literals<readonly ["success", "failure", "neutral"]>;
+    readonly reused: Schema.optionalKey<Schema.Literal<true>>;
+  }>, Schema.Struct<{
+    readonly run: Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">;
+    readonly params: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly rerun: Schema.Int;
+    readonly rerunOf: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">>;
+    readonly got: Schema.Literals<readonly ["new", "joined", "answered"]>;
+    readonly reusedFrom: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">>;
+    readonly readsMoved: Schema.optionalKey<Schema.String>;
+    readonly reuseSkipped: Schema.optionalKey<Schema.String>;
+    readonly state: Schema.Literal<"ended">;
+    readonly error: Schema.Literals<readonly ["timeout", "threw", "invalid output", "unavailable", "expired", "cancelled"]>;
+  }>]>>;
+}>, Schema.Struct<{
+  readonly waiting: Schema.Struct<{
+    readonly start: Schema.brand<Schema.TemplateLiteral<readonly ["startwait_", Schema.String]>, "StartWaitId">;
+    readonly check: Schema.brand<Schema.String, "CheckName">;
+    readonly params: Schema.$Array<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    readonly thread: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["thread_", Schema.String]>, "ThreadId">>;
+    readonly waitingSince: Schema.DateTimeUtcFromString;
+    readonly endsAt: Schema.DateTimeUtcFromString;
+    readonly runs: Schema.$Array<Schema.Struct<{
+      readonly workflow: Schema.brand<Schema.String, "WorkflowName">;
+      readonly run: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["workflowrun_", Schema.String]>, "WorkflowRunId">>;
+      readonly title: Schema.optionalKey<Schema.String>;
+      readonly state: Schema.Literals<readonly ["starting", "going", "allowed", "refused", "failed"]>;
+      readonly leaves: Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["ask", "passkey"]>;
+        readonly state: Schema.Literals<readonly ["waiting", "answered", "ended"]>;
+        readonly since: Schema.DateTimeUtcFromString;
+        readonly who: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+          readonly kind: Schema.Literal<"person">;
+          readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">;
+          readonly name: Schema.optionalKey<Schema.brand<Schema.String, "OwnerName">>;
+        }>, Schema.Struct<{
+          readonly kind: Schema.Literal<"agent">;
+          readonly handle: Schema.brand<Schema.String, "AgentHandle">;
+        }>, Schema.Struct<{
+          readonly kind: Schema.Literal<"holders">;
+          readonly permission: Schema.String;
+        }>]>>;
+        readonly what: Schema.optionalKey<Schema.String>;
+        readonly answer: Schema.optionalKey<Schema.String>;
+      }>>;
+    }>>;
+  }>;
+}>]>>, Schema.toCodecJson<typeof NotPermitted | typeof ThreadNotFound | typeof RepoNotFound | typeof RequestChanged | typeof RunsBusy | typeof RunRefused | typeof StartNotFound | typeof RunUnavailable>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"restoreSigner", "POST", "/v1/repos/:owner/:repo/checks/signers/restore", Schema.toCodecStringTree<Schema.Struct<{
+  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
+  repo: Schema.brand<Schema.String, "RepoName">;
+}>>, never, Schema.toCodecJson<Schema.Union<readonly [Schema.Struct<{
+  readonly check: Schema.brand<Schema.String, "CheckKey">;
+  readonly attachment: Schema.brand<Schema.TemplateLiteral<readonly ["token_", Schema.String]>, "TokenId">;
+}>, Schema.Struct<{
+  readonly check: Schema.brand<Schema.String, "CheckKey">;
+  readonly person: Schema.brand<Schema.String, "OwnerName">;
+}>]>>, never, Schema.toCodecJson<Schema.Union<readonly [Schema.Struct<{
+  readonly check: Schema.brand<Schema.String, "CheckKey">;
+  readonly attachment: Schema.brand<Schema.TemplateLiteral<readonly ["token_", Schema.String]>, "TokenId">;
+}>, Schema.Struct<{
+  readonly check: Schema.brand<Schema.String, "CheckKey">;
+  readonly person: Schema.brand<Schema.String, "OwnerName">;
+}>]>>, Schema.toCodecJson<typeof NotPermitted | typeof RepoNotFound | typeof SignerNotRevoked>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"start", "POST", "/v1/repos/:owner/:repo/runs", Schema.toCodecStringTree<Schema.Struct<{
+  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
+  repo: Schema.brand<Schema.String, "RepoName">;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+  readonly check: Schema.brand<Schema.String, "CheckKey">;
+  readonly on: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"main">;
+  }>, Schema.Struct<{
+    readonly kind: Schema.Literal<"thread">;
+    readonly thread: Schema.brand<Schema.String, "WrittenThread">;
+    readonly branch: Schema.optionalKey<Schema.String>;
+  }>]>;
+  readonly params: Schema.optionalKey<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+  readonly rerun: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">>;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+  'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
+}>>, Schema.toCodecJson<Schema.Union<readonly [Schema.Struct<{
+  readonly runs: Schema.$Array<Schema.Union<readonly [Schema.Struct<{
+    readonly run: Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">;
+    readonly params: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly rerun: Schema.Int;
+    readonly rerunOf: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">>;
+    readonly got: Schema.Literals<readonly ["new", "joined", "answered"]>;
+    readonly reusedFrom: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">>;
+    readonly readsMoved: Schema.optionalKey<Schema.String>;
+    readonly reuseSkipped: Schema.optionalKey<Schema.String>;
+    readonly state: Schema.Literals<readonly ["waiting", "pending", "starting", "created", "running"]>;
+  }>, Schema.Struct<{
+    readonly run: Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">;
+    readonly params: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly rerun: Schema.Int;
+    readonly rerunOf: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">>;
+    readonly got: Schema.Literals<readonly ["new", "joined", "answered"]>;
+    readonly reusedFrom: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">>;
+    readonly readsMoved: Schema.optionalKey<Schema.String>;
+    readonly reuseSkipped: Schema.optionalKey<Schema.String>;
+    readonly state: Schema.Literal<"ended">;
+    readonly conclusion: Schema.Literals<readonly ["success", "failure", "neutral"]>;
+    readonly reused: Schema.optionalKey<Schema.Literal<true>>;
+  }>, Schema.Struct<{
+    readonly run: Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">;
+    readonly params: Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>;
+    readonly rerun: Schema.Int;
+    readonly rerunOf: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">>;
+    readonly got: Schema.Literals<readonly ["new", "joined", "answered"]>;
+    readonly reusedFrom: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["checkrun_", Schema.String]>, "CheckRunId">>;
+    readonly readsMoved: Schema.optionalKey<Schema.String>;
+    readonly reuseSkipped: Schema.optionalKey<Schema.String>;
+    readonly state: Schema.Literal<"ended">;
+    readonly error: Schema.Literals<readonly ["timeout", "threw", "invalid output", "unavailable", "expired", "cancelled"]>;
+  }>]>>;
+}>, Schema.Struct<{
+  readonly waiting: Schema.Struct<{
+    readonly start: Schema.brand<Schema.TemplateLiteral<readonly ["startwait_", Schema.String]>, "StartWaitId">;
+    readonly check: Schema.brand<Schema.String, "CheckName">;
+    readonly params: Schema.$Array<Schema.$Record<Schema.String, Schema.Codec<Schema.Json, Schema.Json, never, never>>>;
+    readonly thread: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["thread_", Schema.String]>, "ThreadId">>;
+    readonly waitingSince: Schema.DateTimeUtcFromString;
+    readonly endsAt: Schema.DateTimeUtcFromString;
+    readonly runs: Schema.$Array<Schema.Struct<{
+      readonly workflow: Schema.brand<Schema.String, "WorkflowName">;
+      readonly run: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["workflowrun_", Schema.String]>, "WorkflowRunId">>;
+      readonly title: Schema.optionalKey<Schema.String>;
+      readonly state: Schema.Literals<readonly ["starting", "going", "allowed", "refused", "failed"]>;
+      readonly leaves: Schema.$Array<Schema.Struct<{
+        readonly kind: Schema.Literals<readonly ["ask", "passkey"]>;
+        readonly state: Schema.Literals<readonly ["waiting", "answered", "ended"]>;
+        readonly since: Schema.DateTimeUtcFromString;
+        readonly who: Schema.optionalKey<Schema.Union<readonly [Schema.Struct<{
+          readonly kind: Schema.Literal<"person">;
+          readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">;
+          readonly name: Schema.optionalKey<Schema.brand<Schema.String, "OwnerName">>;
+        }>, Schema.Struct<{
+          readonly kind: Schema.Literal<"agent">;
+          readonly handle: Schema.brand<Schema.String, "AgentHandle">;
+        }>, Schema.Struct<{
+          readonly kind: Schema.Literal<"holders">;
+          readonly permission: Schema.String;
+        }>]>>;
+        readonly what: Schema.optionalKey<Schema.String>;
+        readonly answer: Schema.optionalKey<Schema.String>;
+      }>>;
+    }>>;
+  }>;
+}>]>>, Schema.toCodecJson<typeof NotPermitted | typeof ThreadNotFound | typeof RepoNotFound | typeof RequestChanged | typeof RunsBusy | typeof RunRefused | typeof RunUnavailable | typeof CheckNotFound | typeof NoThreadHead>, Authorization, never>, false>;
+/**
+ * A repo's check runs: starting them, on `main` or a thread's head, for whoever's token reaches
+ * `check:run` there, and listing them, one scope at a time, for whoever sees it. A person's start
+ * outside a session runs by their approval; an agent's from its session, by its own token. What
+ * a local run of a check runs, and its report, of an identity an open version of a thread needs,
+ * each by whoever may start runs on that thread, the report from the attachment it ran on; and an
+ * admin's restore of a signer a miss revoked. And one run's trace, a check run's or a workflow
+ * run's of the repo's project, a page at a time, for whoever sees the scope it was first started
+ * in.
+ */
+declare class RunsGroup extends RunsGroup_base {}
+declare const ClientGrantsGroup_base: HttpApiGroup.HttpApiGroup<"clientGrants", HttpApiEndpoint.HttpApiEndpoint<"asked", "POST", "/v1/owners/:owner/client-grants/asked", Schema.toCodecStringTree<Schema.Struct<{
+  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
 }>>, never, Schema.toCodecJson<Schema.Struct<{
   readonly request: Schema.String;
 }>>, never, Schema.toCodecJson<Schema.Struct<{
@@ -17974,7 +18169,23 @@ declare const ClientGrantsGroup_base: HttpApiGroup.HttpApiGroup<"clientGrants",
   readonly request: Schema.String;
 }>>, never, Schema.toCodecJson<Schema.Struct<{
   readonly redirect: Schema.String;
-}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof ConsentRefused>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"finish", "POST", "/v1/owners/:owner/client-grants/:grant/finish", Schema.toCodecStringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof ConsentRefused>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"grant", "POST", "/v1/owners/:owner/client-grants", Schema.toCodecStringTree<Schema.Struct<{
+  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+  readonly client: Schema.String;
+  readonly agent: Schema.brand<Schema.String, "AgentHandle">;
+  readonly create: Schema.optionalKey<Schema.Boolean>;
+  readonly access: Schema.Literals<readonly ["read", "act"]>;
+  readonly projects: Schema.NonEmptyArray<Schema.Struct<{
+    readonly owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
+    readonly project: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["project_", Schema.String]>, "ProjectId">, Schema.brand<Schema.String, "ProjectName">]>;
+  }>>;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+  'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
+}>>, Schema.toCodecJson<Schema.Struct<{
+  readonly grant: Schema.brand<Schema.TemplateLiteral<readonly ["token_", Schema.String]>, "TokenId">;
+  readonly client: Schema.String;
+}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof DeliveryOutsideWindow | typeof CommandRefused | typeof ApprovalNeeded | typeof SlowDown | typeof ConsentRefused>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"finish", "POST", "/v1/owners/:owner/client-grants/:grant/finish", Schema.toCodecStringTree<Schema.Struct<{
   owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
   grant: Schema.brand<Schema.TemplateLiteral<readonly ["token_", Schema.String]>, "TokenId">;
 }>>, never, Schema.toCodecJson<Schema.Struct<{
@@ -17990,17 +18201,50 @@ declare const ClientGrantsGroup_base: HttpApiGroup.HttpApiGroup<"clientGrants",
  * consented, hands the client its code.
  */
 declare class ClientGrantsGroup extends ClientGrantsGroup_base {}
-declare const OrganizationsGroup_base: HttpApiGroup.HttpApiGroup<"organizations", HttpApiEndpoint.HttpApiEndpoint<"create", "POST", "/v1/organizations", never, never, Schema.toCodecJson<Schema.Struct<{
-  readonly name: Schema.brand<Schema.String, "OwnerName">;
-  readonly displayName: Schema.optionalKey<Schema.String>;
+declare const OrganizationsGroup_base: HttpApiGroup.HttpApiGroup<"organizations", HttpApiEndpoint.HttpApiEndpoint<"meters", "GET", "/v1/owners/:owner/meters", Schema.toCodecStringTree<Schema.Struct<{
+  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
 }>>, Schema.toCodecStringTree<Schema.Struct<{
-  'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
-}>>, Schema.toCodecJson<Schema.Struct<{
-  readonly owner: Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">;
-  readonly name: Schema.brand<Schema.String, "OwnerName">;
-  readonly displayName: Schema.String;
-  readonly state: Schema.Literals<readonly ["initializing", "ready"]>;
-}>>, Schema.toCodecJson<typeof NameTaken | typeof NameReserved | typeof NotPermitted | typeof AuthorityUnavailable | typeof DeliveryOutsideWindow>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"mine", "GET", "/v1/me/organizations", never, Schema.toCodecStringTree<Schema.Struct<{
+  from: Schema.optionalKey<Schema.brand<Schema.String, "UtcDay">>;
+  to: Schema.optionalKey<Schema.brand<Schema.String, "UtcDay">>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+  readonly from: Schema.brand<Schema.String, "UtcDay">;
+  readonly to: Schema.brand<Schema.String, "UtcDay">;
+  readonly days: Schema.$Array<Schema.Struct<{
+    readonly day: Schema.brand<Schema.String, "UtcDay">;
+    readonly lines: Schema.$Array<Schema.Struct<{
+      readonly meter: Schema.Literals<readonly ["containers.vcpu_seconds", "containers.memory_gib_seconds", "containers.disk_gb_seconds", "containers.egress_gb", "browser.seconds", "artifacts.bytes", "r2.bytes"]>;
+      readonly quantity: Schema.Finite;
+      readonly known: Schema.Literals<readonly ["measured", "estimated"]>;
+    }>>;
+  }>>;
+  readonly work: Schema.$Array<Schema.Struct<{
+    readonly work: Schema.optionalKey<Schema.Literals<readonly ["sandbox", "check run", "merge queue", "snapshot build"]>>;
+    readonly repo: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["repo_", Schema.String]>, "RepoId">>;
+    readonly name: Schema.optionalKey<Schema.brand<Schema.String, "RepoName">>;
+    readonly lines: Schema.$Array<Schema.Struct<{
+      readonly meter: Schema.Literals<readonly ["containers.vcpu_seconds", "containers.memory_gib_seconds", "containers.disk_gb_seconds", "containers.egress_gb", "browser.seconds", "artifacts.bytes", "r2.bytes"]>;
+      readonly quantity: Schema.Finite;
+      readonly known: Schema.Literals<readonly ["measured", "estimated"]>;
+    }>>;
+  }>>;
+  readonly kept: Schema.optionalKey<Schema.Struct<{
+    readonly day: Schema.brand<Schema.String, "UtcDay">;
+    readonly counts: Schema.$Array<Schema.Struct<{
+      readonly repo: Schema.brand<Schema.TemplateLiteral<readonly ["repo_", Schema.String]>, "RepoId">;
+      readonly name: Schema.optionalKey<Schema.brand<Schema.String, "RepoName">>;
+      readonly fork: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["fork_", Schema.String]>, "ForkId">>;
+      readonly store: Schema.Literals<readonly ["artifacts", "r2"]>;
+      readonly bytes: Schema.Int;
+      readonly known: Schema.Literals<readonly ["measured", "estimated"]>;
+    }>>;
+    readonly others: Schema.optionalKey<Schema.$Array<Schema.Struct<{
+      readonly store: Schema.Literals<readonly ["artifacts", "r2"]>;
+      readonly known: Schema.Literals<readonly ["measured", "estimated"]>;
+      readonly counts: Schema.Int;
+      readonly bytes: Schema.Int;
+    }>>>;
+  }>>;
+}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof UsageRangeRefused | typeof OrganizationNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"mine", "GET", "/v1/me/organizations", never, Schema.toCodecStringTree<Schema.Struct<{
   cursor: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">>;
 }>>, never, never, Schema.toCodecJson<Schema.Struct<{
   readonly organizations: Schema.$Array<Schema.Struct<{
@@ -18009,23 +18253,7 @@ declare const OrganizationsGroup_base: HttpApiGroup.HttpApiGroup<"organizations"
     readonly role: Schema.Literals<readonly ["admin", "member"]>;
   }>>;
   readonly next: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">>;
-}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"leave", "DELETE", "/v1/me/organizations/:owner", Schema.toCodecStringTree<Schema.Struct<{
-  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
-}>>, never, never, Schema.toCodecStringTree<Schema.Struct<{
-  'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
-}>>, Schema.toCodecJson<Schema.Struct<{
-  readonly member: Schema.Union<readonly [Schema.Struct<{
-    readonly kind: Schema.Literal<"person">;
-    readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">;
-  }>, Schema.Struct<{
-    readonly kind: Schema.Literal<"agent">;
-    readonly agent: Schema.Struct<{
-      readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
-      readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
-    }>;
-  }>]>;
-  readonly why: Schema.Literals<readonly ["removed", "left"]>;
-}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof DeliveryOutsideWindow | typeof MemberNotFound | typeof LastAdmin | typeof OrganizationNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"usage", "GET", "/v1/owners/:owner/usage", Schema.toCodecStringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"usage", "GET", "/v1/owners/:owner/usage", Schema.toCodecStringTree<Schema.Struct<{
   owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
 }>>, Schema.toCodecStringTree<Schema.Struct<{
   from: Schema.optionalKey<Schema.brand<Schema.String, "UtcDay">>;
@@ -18200,50 +18428,33 @@ declare const OrganizationsGroup_base: HttpApiGroup.HttpApiGroup<"organizations"
     }>>;
   }>;
   readonly pricesAsOf: Schema.String;
-}>]>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof UsageRangeRefused | typeof OrganizationNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"meters", "GET", "/v1/owners/:owner/meters", Schema.toCodecStringTree<Schema.Struct<{
+}>]>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof UsageRangeRefused | typeof OrganizationNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"leave", "DELETE", "/v1/me/organizations/:owner", Schema.toCodecStringTree<Schema.Struct<{
   owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
+}>>, never, never, Schema.toCodecStringTree<Schema.Struct<{
+  'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
+}>>, Schema.toCodecJson<Schema.Struct<{
+  readonly member: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"person">;
+    readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">;
+  }>, Schema.Struct<{
+    readonly kind: Schema.Literal<"agent">;
+    readonly agent: Schema.Struct<{
+      readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
+      readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
+    }>;
+  }>]>;
+  readonly why: Schema.Literals<readonly ["removed", "left"]>;
+}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof DeliveryOutsideWindow | typeof MemberNotFound | typeof LastAdmin | typeof OrganizationNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"create", "POST", "/v1/organizations", never, never, Schema.toCodecJson<Schema.Struct<{
+  readonly name: Schema.brand<Schema.String, "OwnerName">;
+  readonly displayName: Schema.optionalKey<Schema.String>;
 }>>, Schema.toCodecStringTree<Schema.Struct<{
-  from: Schema.optionalKey<Schema.brand<Schema.String, "UtcDay">>;
-  to: Schema.optionalKey<Schema.brand<Schema.String, "UtcDay">>;
-}>>, never, never, Schema.toCodecJson<Schema.Struct<{
-  readonly from: Schema.brand<Schema.String, "UtcDay">;
-  readonly to: Schema.brand<Schema.String, "UtcDay">;
-  readonly days: Schema.$Array<Schema.Struct<{
-    readonly day: Schema.brand<Schema.String, "UtcDay">;
-    readonly lines: Schema.$Array<Schema.Struct<{
-      readonly meter: Schema.Literals<readonly ["containers.vcpu_seconds", "containers.memory_gib_seconds", "containers.disk_gb_seconds", "containers.egress_gb", "browser.seconds", "artifacts.bytes", "r2.bytes"]>;
-      readonly quantity: Schema.Finite;
-      readonly known: Schema.Literals<readonly ["measured", "estimated"]>;
-    }>>;
-  }>>;
-  readonly work: Schema.$Array<Schema.Struct<{
-    readonly work: Schema.optionalKey<Schema.Literals<readonly ["sandbox", "check run", "merge queue", "snapshot build"]>>;
-    readonly repo: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["repo_", Schema.String]>, "RepoId">>;
-    readonly name: Schema.optionalKey<Schema.brand<Schema.String, "RepoName">>;
-    readonly lines: Schema.$Array<Schema.Struct<{
-      readonly meter: Schema.Literals<readonly ["containers.vcpu_seconds", "containers.memory_gib_seconds", "containers.disk_gb_seconds", "containers.egress_gb", "browser.seconds", "artifacts.bytes", "r2.bytes"]>;
-      readonly quantity: Schema.Finite;
-      readonly known: Schema.Literals<readonly ["measured", "estimated"]>;
-    }>>;
-  }>>;
-  readonly kept: Schema.optionalKey<Schema.Struct<{
-    readonly day: Schema.brand<Schema.String, "UtcDay">;
-    readonly counts: Schema.$Array<Schema.Struct<{
-      readonly repo: Schema.brand<Schema.TemplateLiteral<readonly ["repo_", Schema.String]>, "RepoId">;
-      readonly name: Schema.optionalKey<Schema.brand<Schema.String, "RepoName">>;
-      readonly fork: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["fork_", Schema.String]>, "ForkId">>;
-      readonly store: Schema.Literals<readonly ["artifacts", "r2"]>;
-      readonly bytes: Schema.Int;
-      readonly known: Schema.Literals<readonly ["measured", "estimated"]>;
-    }>>;
-    readonly others: Schema.optionalKey<Schema.$Array<Schema.Struct<{
-      readonly store: Schema.Literals<readonly ["artifacts", "r2"]>;
-      readonly known: Schema.Literals<readonly ["measured", "estimated"]>;
-      readonly counts: Schema.Int;
-      readonly bytes: Schema.Int;
-    }>>>;
-  }>>;
-}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof UsageRangeRefused | typeof OrganizationNotFound>, Authorization, never>, false>;
+  'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
+}>>, Schema.toCodecJson<Schema.Struct<{
+  readonly owner: Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">;
+  readonly name: Schema.brand<Schema.String, "OwnerName">;
+  readonly displayName: Schema.String;
+  readonly state: Schema.Literals<readonly ["initializing", "ready"]>;
+}>>, Schema.toCodecJson<typeof NameTaken | typeof NameReserved | typeof NotPermitted | typeof AuthorityUnavailable | typeof DeliveryOutsideWindow>, Authorization, never>, false>;
 /**
  * Organizations (layer 1): making one, the person's own list of theirs, leaving one, and its
  * usage. Every change is a person's, by approval; agents never change members.
@@ -18291,53 +18502,25 @@ declare const MembersGroup_base: HttpApiGroup.HttpApiGroup<"members", HttpApiEnd
   readonly role: Schema.Literals<readonly ["admin", "member"]>;
 }>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof DeliveryOutsideWindow | typeof MemberNotFound | typeof LastAdmin | typeof OrganizationNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"remove", "DELETE", "/v1/owners/:owner/members/:member", Schema.toCodecStringTree<Schema.Struct<{
   owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
-  member: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
-}>>, never, never, Schema.toCodecStringTree<Schema.Struct<{
-  'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
-}>>, Schema.toCodecJson<Schema.Struct<{
-  readonly member: Schema.Union<readonly [Schema.Struct<{
-    readonly kind: Schema.Literal<"person">;
-    readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">;
-  }>, Schema.Struct<{
-    readonly kind: Schema.Literal<"agent">;
-    readonly agent: Schema.Struct<{
-      readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
-      readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
-    }>;
-  }>]>;
-  readonly why: Schema.Literals<readonly ["removed", "left"]>;
-}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof DeliveryOutsideWindow | typeof MemberNotFound | typeof LastAdmin | typeof OrganizationNotFound>, Authorization, never>, false>;
-/** An organization's members: any member lists them; an admin changes a role or removes one. */
-declare class MembersGroup extends MembersGroup_base {}
-declare const InvitationsGroup_base: HttpApiGroup.HttpApiGroup<"invitations", HttpApiEndpoint.HttpApiEndpoint<"received", "GET", "/v1/me/invitations", never, Schema.toCodecStringTree<Schema.Struct<{
-  cursor: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["invitation_", Schema.String]>, "InvitationId">>;
-}>>, never, never, Schema.toCodecJson<Schema.Struct<{
-  readonly invitations: Schema.$Array<Schema.Struct<{
-    readonly invitation: Schema.brand<Schema.TemplateLiteral<readonly ["invitation_", Schema.String]>, "InvitationId">;
-    readonly organization: Schema.Struct<{
-      readonly owner: Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">;
-      readonly name: Schema.brand<Schema.String, "OwnerName">;
-    }>;
-    readonly role: Schema.Literals<readonly ["admin", "member"]>;
-    readonly expiresAt: Schema.DateTimeUtcFromMillis;
-  }>>;
-  readonly next: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["invitation_", Schema.String]>, "InvitationId">>;
-}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"send", "POST", "/v1/owners/:owner/invitations", Schema.toCodecStringTree<Schema.Struct<{
-  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
-}>>, never, Schema.toCodecJson<Schema.Struct<{
-  readonly invitee: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
-  readonly role: Schema.optionalKey<Schema.Literals<readonly ["admin", "member"]>>;
-}>>, Schema.toCodecStringTree<Schema.Struct<{
-  'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
-}>>, Schema.toCodecJson<Schema.Struct<{
-  readonly invitation: Schema.brand<Schema.TemplateLiteral<readonly ["invitation_", Schema.String]>, "InvitationId">;
-  readonly invitee: Schema.Struct<{
-    readonly person: Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">;
-    readonly name: Schema.brand<Schema.String, "OwnerName">;
-  }>;
-  readonly role: Schema.Literals<readonly ["admin", "member"]>;
-  readonly expiresAt: Schema.DateTimeUtcFromMillis;
-}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof DeliveryOutsideWindow | typeof AlreadyMember | typeof InvitationOpen | typeof OrganizationNotFound | typeof PersonNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"list", "GET", "/v1/owners/:owner/invitations", Schema.toCodecStringTree<Schema.Struct<{
+  member: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
+}>>, never, never, Schema.toCodecStringTree<Schema.Struct<{
+  'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
+}>>, Schema.toCodecJson<Schema.Struct<{
+  readonly member: Schema.Union<readonly [Schema.Struct<{
+    readonly kind: Schema.Literal<"person">;
+    readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">;
+  }>, Schema.Struct<{
+    readonly kind: Schema.Literal<"agent">;
+    readonly agent: Schema.Struct<{
+      readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
+      readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
+    }>;
+  }>]>;
+  readonly why: Schema.Literals<readonly ["removed", "left"]>;
+}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof DeliveryOutsideWindow | typeof MemberNotFound | typeof LastAdmin | typeof OrganizationNotFound>, Authorization, never>, false>;
+/** An organization's members: any member lists them; an admin changes a role or removes one. */
+declare class MembersGroup extends MembersGroup_base {}
+declare const InvitationsGroup_base: HttpApiGroup.HttpApiGroup<"invitations", HttpApiEndpoint.HttpApiEndpoint<"list", "GET", "/v1/owners/:owner/invitations", Schema.toCodecStringTree<Schema.Struct<{
   owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
 }>>, Schema.toCodecStringTree<Schema.Struct<{
   cursor: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["invitation_", Schema.String]>, "InvitationId">>;
@@ -18356,14 +18539,29 @@ declare const InvitationsGroup_base: HttpApiGroup.HttpApiGroup<"invitations", Ht
     readonly expiresAt: Schema.DateTimeUtcFromMillis;
   }>>;
   readonly next: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["invitation_", Schema.String]>, "InvitationId">>;
-}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof OrganizationNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"withdraw", "DELETE", "/v1/owners/:owner/invitations/:invitation", Schema.toCodecStringTree<Schema.Struct<{
-  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
+}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof OrganizationNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"received", "GET", "/v1/me/invitations", never, Schema.toCodecStringTree<Schema.Struct<{
+  cursor: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["invitation_", Schema.String]>, "InvitationId">>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+  readonly invitations: Schema.$Array<Schema.Struct<{
+    readonly invitation: Schema.brand<Schema.TemplateLiteral<readonly ["invitation_", Schema.String]>, "InvitationId">;
+    readonly organization: Schema.Struct<{
+      readonly owner: Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">;
+      readonly name: Schema.brand<Schema.String, "OwnerName">;
+    }>;
+    readonly role: Schema.Literals<readonly ["admin", "member"]>;
+    readonly expiresAt: Schema.DateTimeUtcFromMillis;
+  }>>;
+  readonly next: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["invitation_", Schema.String]>, "InvitationId">>;
+}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"accept", "POST", "/v1/me/invitations/:invitation/accept", Schema.toCodecStringTree<Schema.Struct<{
   invitation: Schema.brand<Schema.TemplateLiteral<readonly ["invitation_", Schema.String]>, "InvitationId">;
 }>>, never, never, Schema.toCodecStringTree<Schema.Struct<{
   'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
 }>>, Schema.toCodecJson<Schema.Struct<{
   readonly invitation: Schema.brand<Schema.TemplateLiteral<readonly ["invitation_", Schema.String]>, "InvitationId">;
-}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof DeliveryOutsideWindow | typeof InvitationNotFound | typeof OrganizationNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"accept", "POST", "/v1/me/invitations/:invitation/accept", Schema.toCodecStringTree<Schema.Struct<{
+  readonly organization: Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">;
+  readonly answer: Schema.Literals<readonly ["accept", "decline"]>;
+  readonly role: Schema.Literals<readonly ["admin", "member"]>;
+}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof DeliveryOutsideWindow | typeof InvitationNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"decline", "POST", "/v1/me/invitations/:invitation/decline", Schema.toCodecStringTree<Schema.Struct<{
   invitation: Schema.brand<Schema.TemplateLiteral<readonly ["invitation_", Schema.String]>, "InvitationId">;
 }>>, never, never, Schema.toCodecStringTree<Schema.Struct<{
   'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
@@ -18372,22 +18570,84 @@ declare const InvitationsGroup_base: HttpApiGroup.HttpApiGroup<"invitations", Ht
   readonly organization: Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">;
   readonly answer: Schema.Literals<readonly ["accept", "decline"]>;
   readonly role: Schema.Literals<readonly ["admin", "member"]>;
-}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof DeliveryOutsideWindow | typeof InvitationNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"decline", "POST", "/v1/me/invitations/:invitation/decline", Schema.toCodecStringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof DeliveryOutsideWindow | typeof InvitationNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"withdraw", "DELETE", "/v1/owners/:owner/invitations/:invitation", Schema.toCodecStringTree<Schema.Struct<{
+  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
   invitation: Schema.brand<Schema.TemplateLiteral<readonly ["invitation_", Schema.String]>, "InvitationId">;
 }>>, never, never, Schema.toCodecStringTree<Schema.Struct<{
   'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
 }>>, Schema.toCodecJson<Schema.Struct<{
   readonly invitation: Schema.brand<Schema.TemplateLiteral<readonly ["invitation_", Schema.String]>, "InvitationId">;
-  readonly organization: Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">;
-  readonly answer: Schema.Literals<readonly ["accept", "decline"]>;
+}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof DeliveryOutsideWindow | typeof InvitationNotFound | typeof OrganizationNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"send", "POST", "/v1/owners/:owner/invitations", Schema.toCodecStringTree<Schema.Struct<{
+  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+  readonly invitee: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
+  readonly role: Schema.optionalKey<Schema.Literals<readonly ["admin", "member"]>>;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+  'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
+}>>, Schema.toCodecJson<Schema.Struct<{
+  readonly invitation: Schema.brand<Schema.TemplateLiteral<readonly ["invitation_", Schema.String]>, "InvitationId">;
+  readonly invitee: Schema.Struct<{
+    readonly person: Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">;
+    readonly name: Schema.brand<Schema.String, "OwnerName">;
+  }>;
   readonly role: Schema.Literals<readonly ["admin", "member"]>;
-}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof DeliveryOutsideWindow | typeof InvitationNotFound>, Authorization, never>, false>;
+  readonly expiresAt: Schema.DateTimeUtcFromMillis;
+}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof DeliveryOutsideWindow | typeof AlreadyMember | typeof InvitationOpen | typeof OrganizationNotFound | typeof PersonNotFound>, Authorization, never>, false>;
 /**
  * Invitations: an organization's admins send, list and withdraw them; the person invited lists
  * theirs and accepts or declines one, which is found from their own list, never the client.
  */
 declare class InvitationsGroup extends InvitationsGroup_base {}
-declare const GrantsGroup_base: HttpApiGroup.HttpApiGroup<"grants", HttpApiEndpoint.HttpApiEndpoint<"revoke", "DELETE", "/v1/owners/:owner/grants", Schema.toCodecStringTree<Schema.Struct<{
+declare const GrantsGroup_base: HttpApiGroup.HttpApiGroup<"grants", HttpApiEndpoint.HttpApiEndpoint<"list", "GET", "/v1/owners/:owner/grants", Schema.toCodecStringTree<Schema.Struct<{
+  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+  after: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["event_", Schema.String]>, "EventId">>;
+  limit: Schema.optionalKey<Schema.Int>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+  readonly grants: Schema.$Array<Schema.Struct<{
+    readonly grant: Schema.brand<Schema.TemplateLiteral<readonly ["event_", Schema.String]>, "EventId">;
+    readonly subject: Schema.Union<readonly [Schema.Struct<{
+      readonly kind: Schema.Literal<"owner">;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"project">;
+      readonly project: Schema.brand<Schema.String, "ProjectName">;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"thread">;
+      readonly thread: Schema.brand<Schema.String, "WrittenThread">;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"agent">;
+      readonly handle: Schema.brand<Schema.String, "AgentHandle">;
+    }>]>;
+    readonly principal: Schema.Union<readonly [Schema.Struct<{
+      readonly kind: Schema.Literal<"person">;
+      readonly name: Schema.brand<Schema.String, "OwnerName">;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"agent">;
+      readonly owner: Schema.brand<Schema.String, "OwnerName">;
+      readonly handle: Schema.brand<Schema.String, "AgentHandle">;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"agent">;
+      readonly agent: Schema.Struct<{
+        readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
+        readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
+      }>;
+    }>]>;
+    readonly role: Schema.Literals<readonly ["read", "write", "attach", "manage"]>;
+    readonly grantedBy: Schema.Union<readonly [Schema.Struct<{
+      readonly kind: Schema.Literal<"person">;
+      readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"agent">;
+      readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
+      readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"ref0">;
+      readonly id: Schema.Literals<("ref0:attachments" | "ref0:barrier" | "ref0:blockers" | "ref0:checks" | "ref0:gate" | "ref0:hooks" | "ref0:importer" | "ref0:invitations" | "ref0:listings" | "ref0:mirror" | "ref0:needs" | "ref0:oauth" | "ref0:owners" | "ref0:plans" | "ref0:prepare" | "ref0:project-gate" | "ref0:pushes" | "ref0:queue" | "ref0:rebuilder" | "ref0:sessions" | "ref0:sign-in" | "ref0:stages" | "ref0:sweeper" | "ref0:usage" | "ref0:warm-up" | "ref0:workflows")[]>;
+    }>]>;
+    readonly grantedAt: Schema.DateTimeUtcFromMillis;
+  }>>;
+  readonly nextAfter: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["event_", Schema.String]>, "EventId">>;
+}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof OrganizationNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"revoke", "DELETE", "/v1/owners/:owner/grants", Schema.toCodecStringTree<Schema.Struct<{
   owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
 }>>, never, Schema.toCodecJson<Schema.Struct<{
   readonly subject: Schema.Union<readonly [Schema.Struct<{
@@ -18499,56 +18759,7 @@ declare const GrantsGroup_base: HttpApiGroup.HttpApiGroup<"grants", HttpApiEndpo
     }>;
   }>]>;
   readonly role: Schema.Literals<readonly ["read", "write", "attach", "manage"]>;
-}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof DeliveryOutsideWindow | typeof MemberNotFound | typeof OrganizationNotFound | typeof SubjectNotFound | typeof RoleNotFitting>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"list", "GET", "/v1/owners/:owner/grants", Schema.toCodecStringTree<Schema.Struct<{
-  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
-}>>, Schema.toCodecStringTree<Schema.Struct<{
-  after: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["event_", Schema.String]>, "EventId">>;
-  limit: Schema.optionalKey<Schema.Int>;
-}>>, never, never, Schema.toCodecJson<Schema.Struct<{
-  readonly grants: Schema.$Array<Schema.Struct<{
-    readonly grant: Schema.brand<Schema.TemplateLiteral<readonly ["event_", Schema.String]>, "EventId">;
-    readonly subject: Schema.Union<readonly [Schema.Struct<{
-      readonly kind: Schema.Literal<"owner">;
-    }>, Schema.Struct<{
-      readonly kind: Schema.Literal<"project">;
-      readonly project: Schema.brand<Schema.String, "ProjectName">;
-    }>, Schema.Struct<{
-      readonly kind: Schema.Literal<"thread">;
-      readonly thread: Schema.brand<Schema.String, "WrittenThread">;
-    }>, Schema.Struct<{
-      readonly kind: Schema.Literal<"agent">;
-      readonly handle: Schema.brand<Schema.String, "AgentHandle">;
-    }>]>;
-    readonly principal: Schema.Union<readonly [Schema.Struct<{
-      readonly kind: Schema.Literal<"person">;
-      readonly name: Schema.brand<Schema.String, "OwnerName">;
-    }>, Schema.Struct<{
-      readonly kind: Schema.Literal<"agent">;
-      readonly owner: Schema.brand<Schema.String, "OwnerName">;
-      readonly handle: Schema.brand<Schema.String, "AgentHandle">;
-    }>, Schema.Struct<{
-      readonly kind: Schema.Literal<"agent">;
-      readonly agent: Schema.Struct<{
-        readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
-        readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
-      }>;
-    }>]>;
-    readonly role: Schema.Literals<readonly ["read", "write", "attach", "manage"]>;
-    readonly grantedBy: Schema.Union<readonly [Schema.Struct<{
-      readonly kind: Schema.Literal<"person">;
-      readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">;
-    }>, Schema.Struct<{
-      readonly kind: Schema.Literal<"agent">;
-      readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
-      readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
-    }>, Schema.Struct<{
-      readonly kind: Schema.Literal<"ref0">;
-      readonly id: Schema.Literals<("ref0:attachments" | "ref0:barrier" | "ref0:blockers" | "ref0:checks" | "ref0:gate" | "ref0:hooks" | "ref0:importer" | "ref0:invitations" | "ref0:listings" | "ref0:mirror" | "ref0:needs" | "ref0:oauth" | "ref0:owners" | "ref0:plans" | "ref0:prepare" | "ref0:project-gate" | "ref0:pushes" | "ref0:queue" | "ref0:rebuilder" | "ref0:sessions" | "ref0:sign-in" | "ref0:stages" | "ref0:sweeper" | "ref0:usage" | "ref0:warm-up" | "ref0:workflows")[]>;
-    }>]>;
-    readonly grantedAt: Schema.DateTimeUtcFromMillis;
-  }>>;
-  readonly nextAfter: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["event_", Schema.String]>, "EventId">>;
-}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof OrganizationNotFound>, Authorization, never>, false>;
+}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof DeliveryOutsideWindow | typeof MemberNotFound | typeof OrganizationNotFound | typeof SubjectNotFound | typeof RoleNotFitting>, Authorization, never>, false>;
 /**
  * An organization's grants (layer 1): any person lists those they may see; an admin gives one or
  * takes one back, by approval, naming it in the body, `DELETE` too. People only: agents never
@@ -18556,13 +18767,10 @@ declare const GrantsGroup_base: HttpApiGroup.HttpApiGroup<"grants", HttpApiEndpo
  * `OrganizationNotFound`.
  */
 declare class GrantsGroup extends GrantsGroup_base {}
-declare const AgentsGroup_base: HttpApiGroup.HttpApiGroup<"agents", HttpApiEndpoint.HttpApiEndpoint<"add", "POST", "/v1/owners/:owner/agents", Schema.toCodecStringTree<Schema.Struct<{
+declare const AgentsGroup_base: HttpApiGroup.HttpApiGroup<"agents", HttpApiEndpoint.HttpApiEndpoint<"get", "GET", "/v1/owners/:owner/agents/:agent", Schema.toCodecStringTree<Schema.Struct<{
   owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
-}>>, never, Schema.toCodecJson<Schema.Struct<{
-  readonly handle: Schema.brand<Schema.String, "AgentHandle">;
-}>>, Schema.toCodecStringTree<Schema.Struct<{
-  'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
-}>>, Schema.toCodecJson<Schema.Struct<{
+  agent: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">, Schema.brand<Schema.String, "AgentHandle">]>;
+}>>, never, never, never, Schema.toCodecJson<Schema.Struct<{
   readonly agent: Schema.Struct<{
     readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
     readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
@@ -18570,10 +18778,29 @@ declare const AgentsGroup_base: HttpApiGroup.HttpApiGroup<"agents", HttpApiEndpo
   readonly handle: Schema.brand<Schema.String, "AgentHandle">;
   readonly generation: Schema.Int;
   readonly turnedOff: Schema.Boolean;
-}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof HandleTaken | typeof DeliveryOutsideWindow | typeof OrganizationNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"disable", "POST", "/v1/owners/:owner/agents/:agent/disable", Schema.toCodecStringTree<Schema.Struct<{
+  readonly addedAt: Schema.DateTimeUtcFromMillis;
+}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof AgentNotFound | typeof OrganizationNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"list", "GET", "/v1/owners/:owner/agents", Schema.toCodecStringTree<Schema.Struct<{
   owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
-  agent: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">, Schema.brand<Schema.String, "AgentHandle">]>;
-}>>, never, never, Schema.toCodecStringTree<Schema.Struct<{
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+  after: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">>;
+  limit: Schema.optionalKey<Schema.Int>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+  readonly agents: Schema.$Array<Schema.Struct<{
+    readonly agent: Schema.Struct<{
+      readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
+      readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
+    }>;
+    readonly handle: Schema.brand<Schema.String, "AgentHandle">;
+    readonly generation: Schema.Int;
+    readonly turnedOff: Schema.Boolean;
+    readonly addedAt: Schema.DateTimeUtcFromMillis;
+  }>>;
+  readonly nextAfter: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">>;
+}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof OrganizationNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"add", "POST", "/v1/owners/:owner/agents", Schema.toCodecStringTree<Schema.Struct<{
+  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
+}>>, never, Schema.toCodecJson<Schema.Struct<{
+  readonly handle: Schema.brand<Schema.String, "AgentHandle">;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
   'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
 }>>, Schema.toCodecJson<Schema.Struct<{
   readonly agent: Schema.Struct<{
@@ -18583,7 +18810,7 @@ declare const AgentsGroup_base: HttpApiGroup.HttpApiGroup<"agents", HttpApiEndpo
   readonly handle: Schema.brand<Schema.String, "AgentHandle">;
   readonly generation: Schema.Int;
   readonly turnedOff: Schema.Boolean;
-}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof AgentNotFound | typeof DeliveryOutsideWindow | typeof OrganizationNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"enable", "POST", "/v1/owners/:owner/agents/:agent/enable", Schema.toCodecStringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof HandleTaken | typeof DeliveryOutsideWindow | typeof OrganizationNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"disable", "POST", "/v1/owners/:owner/agents/:agent/disable", Schema.toCodecStringTree<Schema.Struct<{
   owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
   agent: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">, Schema.brand<Schema.String, "AgentHandle">]>;
 }>>, never, never, Schema.toCodecStringTree<Schema.Struct<{
@@ -18596,10 +18823,12 @@ declare const AgentsGroup_base: HttpApiGroup.HttpApiGroup<"agents", HttpApiEndpo
   readonly handle: Schema.brand<Schema.String, "AgentHandle">;
   readonly generation: Schema.Int;
   readonly turnedOff: Schema.Boolean;
-}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof AgentNotFound | typeof DeliveryOutsideWindow | typeof OrganizationNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"get", "GET", "/v1/owners/:owner/agents/:agent", Schema.toCodecStringTree<Schema.Struct<{
+}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof AgentNotFound | typeof DeliveryOutsideWindow | typeof OrganizationNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"enable", "POST", "/v1/owners/:owner/agents/:agent/enable", Schema.toCodecStringTree<Schema.Struct<{
   owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
   agent: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">, Schema.brand<Schema.String, "AgentHandle">]>;
-}>>, never, never, never, Schema.toCodecJson<Schema.Struct<{
+}>>, never, never, Schema.toCodecStringTree<Schema.Struct<{
+  'idempotency-key': Schema.brand<Schema.TemplateLiteral<readonly ["request_", Schema.String]>, "RequestId">;
+}>>, Schema.toCodecJson<Schema.Struct<{
   readonly agent: Schema.Struct<{
     readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
     readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
@@ -18607,25 +18836,7 @@ declare const AgentsGroup_base: HttpApiGroup.HttpApiGroup<"agents", HttpApiEndpo
   readonly handle: Schema.brand<Schema.String, "AgentHandle">;
   readonly generation: Schema.Int;
   readonly turnedOff: Schema.Boolean;
-  readonly addedAt: Schema.DateTimeUtcFromMillis;
-}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof AgentNotFound | typeof OrganizationNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"list", "GET", "/v1/owners/:owner/agents", Schema.toCodecStringTree<Schema.Struct<{
-  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
-}>>, Schema.toCodecStringTree<Schema.Struct<{
-  after: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">>;
-  limit: Schema.optionalKey<Schema.Int>;
-}>>, never, never, Schema.toCodecJson<Schema.Struct<{
-  readonly agents: Schema.$Array<Schema.Struct<{
-    readonly agent: Schema.Struct<{
-      readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
-      readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
-    }>;
-    readonly handle: Schema.brand<Schema.String, "AgentHandle">;
-    readonly generation: Schema.Int;
-    readonly turnedOff: Schema.Boolean;
-    readonly addedAt: Schema.DateTimeUtcFromMillis;
-  }>>;
-  readonly nextAfter: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">>;
-}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof OrganizationNotFound>, Authorization, never>, false>;
+}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof AgentNotFound | typeof DeliveryOutsideWindow | typeof OrganizationNotFound>, Authorization, never>, false>;
 /**
  * An owner's agents (layer 1): an organization's members, or a person themselves, read them and
  * turn one off everywhere, or on again; an organization's admin adds one, and only an admin turns
@@ -18678,7 +18889,34 @@ declare const AuthorizationsGroup_base: HttpApiGroup.HttpApiGroup<"authorization
  * decides. People only, by approval.
  */
 declare class AuthorizationsGroup extends AuthorizationsGroup_base {}
-declare const AgentDisablesGroup_base: HttpApiGroup.HttpApiGroup<"agentDisables", HttpApiEndpoint.HttpApiEndpoint<"add", "POST", "/v1/owners/:owner/agent-disables", Schema.toCodecStringTree<Schema.Struct<{
+declare const AgentDisablesGroup_base: HttpApiGroup.HttpApiGroup<"agentDisables", HttpApiEndpoint.HttpApiEndpoint<"list", "GET", "/v1/owners/:owner/agent-disables", Schema.toCodecStringTree<Schema.Struct<{
+  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
+}>>, Schema.toCodecStringTree<Schema.Struct<{
+  after: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">>;
+  limit: Schema.optionalKey<Schema.Int>;
+}>>, never, never, Schema.toCodecJson<Schema.Struct<{
+  readonly disables: Schema.$Array<Schema.Struct<{
+    readonly agent: Schema.Struct<{
+      readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
+      readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
+    }>;
+    readonly owner: Schema.optionalKey<Schema.brand<Schema.String, "OwnerName">>;
+    readonly handle: Schema.optionalKey<Schema.brand<Schema.String, "AgentHandle">>;
+    readonly disabledBy: Schema.Union<readonly [Schema.Struct<{
+      readonly kind: Schema.Literal<"person">;
+      readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"agent">;
+      readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
+      readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
+    }>, Schema.Struct<{
+      readonly kind: Schema.Literal<"ref0">;
+      readonly id: Schema.Literals<("ref0:attachments" | "ref0:barrier" | "ref0:blockers" | "ref0:checks" | "ref0:gate" | "ref0:hooks" | "ref0:importer" | "ref0:invitations" | "ref0:listings" | "ref0:mirror" | "ref0:needs" | "ref0:oauth" | "ref0:owners" | "ref0:plans" | "ref0:prepare" | "ref0:project-gate" | "ref0:pushes" | "ref0:queue" | "ref0:rebuilder" | "ref0:sessions" | "ref0:sign-in" | "ref0:stages" | "ref0:sweeper" | "ref0:usage" | "ref0:warm-up" | "ref0:workflows")[]>;
+    }>]>;
+    readonly disabledAt: Schema.DateTimeUtcFromMillis;
+  }>>;
+  readonly nextAfter: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">>;
+}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof OrganizationNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"add", "POST", "/v1/owners/:owner/agent-disables", Schema.toCodecStringTree<Schema.Struct<{
   owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
 }>>, never, Schema.toCodecJson<Schema.Struct<{
   readonly agent: Schema.Struct<{
@@ -18710,34 +18948,7 @@ declare const AgentDisablesGroup_base: HttpApiGroup.HttpApiGroup<"agentDisables"
   }>;
   readonly targetGeneration: Schema.Int;
   readonly turnedOff: Schema.Boolean;
-}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof AgentNotFound | typeof DeliveryOutsideWindow | typeof OrganizationNotFound>, Authorization, never> | HttpApiEndpoint.HttpApiEndpoint<"list", "GET", "/v1/owners/:owner/agent-disables", Schema.toCodecStringTree<Schema.Struct<{
-  owner: Schema.Union<readonly [Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>, Schema.brand<Schema.String, "OwnerName">]>;
-}>>, Schema.toCodecStringTree<Schema.Struct<{
-  after: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">>;
-  limit: Schema.optionalKey<Schema.Int>;
-}>>, never, never, Schema.toCodecJson<Schema.Struct<{
-  readonly disables: Schema.$Array<Schema.Struct<{
-    readonly agent: Schema.Struct<{
-      readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
-      readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
-    }>;
-    readonly owner: Schema.optionalKey<Schema.brand<Schema.String, "OwnerName">>;
-    readonly handle: Schema.optionalKey<Schema.brand<Schema.String, "AgentHandle">>;
-    readonly disabledBy: Schema.Union<readonly [Schema.Struct<{
-      readonly kind: Schema.Literal<"person">;
-      readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">;
-    }>, Schema.Struct<{
-      readonly kind: Schema.Literal<"agent">;
-      readonly id: Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">;
-      readonly owner: Schema.Union<readonly [Schema.brand<Schema.TemplateLiteral<readonly ["person_", Schema.String]>, "PersonId">, Schema.brand<Schema.TemplateLiteral<readonly ["org_", Schema.String]>, "OrgId">]>;
-    }>, Schema.Struct<{
-      readonly kind: Schema.Literal<"ref0">;
-      readonly id: Schema.Literals<("ref0:attachments" | "ref0:barrier" | "ref0:blockers" | "ref0:checks" | "ref0:gate" | "ref0:hooks" | "ref0:importer" | "ref0:invitations" | "ref0:listings" | "ref0:mirror" | "ref0:needs" | "ref0:oauth" | "ref0:owners" | "ref0:plans" | "ref0:prepare" | "ref0:project-gate" | "ref0:pushes" | "ref0:queue" | "ref0:rebuilder" | "ref0:sessions" | "ref0:sign-in" | "ref0:stages" | "ref0:sweeper" | "ref0:usage" | "ref0:warm-up" | "ref0:workflows")[]>;
-    }>]>;
-    readonly disabledAt: Schema.DateTimeUtcFromMillis;
-  }>>;
-  readonly nextAfter: Schema.optionalKey<Schema.brand<Schema.TemplateLiteral<readonly ["agent_", Schema.String]>, "AgentId">>;
-}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof OrganizationNotFound>, Authorization, never>, false>;
+}>>, Schema.toCodecJson<typeof NotPermitted | typeof AuthorityUnavailable | typeof AgentNotFound | typeof DeliveryOutsideWindow | typeof OrganizationNotFound>, Authorization, never>, false>;
 /**
  * Agents of other owners an organization's admin turns off there (layer 1), such as a member's
  * own, named in the body, `DELETE` too, since a handle alone can't tell `pip/claude` from
@@ -27268,7 +27479,9 @@ type LiveTicket = typeof LiveTicket.Type;
  * Who a passkey request asks: the accountable person; a person, by their name; or anyone holding
  * one of the repo's permissions, the first of whom to answer decides. Until a permission's holders
  * are kept, they're its owner's admins. A workflow run's `passkey.run` asks its run's accountable
- * person; a gate's `passkey.check` asks the person behind the run that meets its need.
+ * person; a gate's `passkey.check` asks the person behind the run that meets its need. A person or
+ * a permission is someone else, a second pair of eyes, so the person `'accountable'` would ask
+ * never answers it: a request with nobody else to ask is refused.
  */
 declare const PasskeyFrom: Schema.Union<readonly [Schema.Literal<"accountable">, Schema.Struct<{
   readonly person: Schema.brand<Schema.String, "OwnerName">;
@@ -28783,6 +28996,8 @@ type WorkflowPasskeyAsk = typeof WorkflowPasskeyAsk.Type;
  * - `undeclared`: the workflow's `permissions.ask` doesn't name this kind of `from`, or the
  *   statement isn't one of its code's templates.
  * - `target`: no such person, or one who can't see where the workflow lives.
+ * - `self`: `from` names the run's accountable person, or a permission they alone hold. A yes from
+ *   someone else is a second pair of eyes only when it isn't theirs: `'accountable'` asks them.
  * - `budget`: the run has asked as much as its `asks` budget allows, or its workflow as many as a
  *   day allows.
  * - `length`: the statement is longer than one may be.
@@ -28793,7 +29008,7 @@ type WorkflowPasskeyAsk = typeof WorkflowPasskeyAsk.Type;
  * - `agent`: `from` names an agent, such as one that answered an ask, and an agent has no passkey.
  *   The SDK refuses it before asking ref0.
  */
-declare const PasskeyRefusal: Schema.Literals<readonly ["undeclared", "target", "budget", "length", "secret", "ended", "changed", "invalid", "agent"]>;
+declare const PasskeyRefusal: Schema.Literals<readonly ["undeclared", "target", "self", "budget", "length", "secret", "ended", "changed", "invalid", "agent"]>;
 type PasskeyRefusal = typeof PasskeyRefusal.Type;
 /** ref0's answer to a `passkey.run`'s ask: the request, or why not. A refusal is never thrown. */
 declare const WorkflowPasskeyAsked: Schema.Union<readonly [Schema.Struct<{
@@ -28801,7 +29016,7 @@ declare const WorkflowPasskeyAsked: Schema.Union<readonly [Schema.Struct<{
   readonly request: Schema.brand<Schema.TemplateLiteral<readonly ["approval_", Schema.String]>, "ApprovalId">;
 }>, Schema.Struct<{
   readonly kind: Schema.Literal<"refused">;
-  readonly why: Schema.Literals<readonly ["undeclared", "target", "budget", "length", "secret", "ended", "changed", "invalid", "agent"]>;
+  readonly why: Schema.Literals<readonly ["undeclared", "target", "self", "budget", "length", "secret", "ended", "changed", "invalid", "agent"]>;
 }>]>;
 type WorkflowPasskeyAsked = typeof WorkflowPasskeyAsked.Type;
 /** A run's read of one of its requests. */
@@ -28981,5 +29196,5 @@ declare const SandboxExecAnswer: Schema.Union<readonly [Schema.Struct<{
 }>]>;
 type SandboxExecAnswer = typeof SandboxExecAnswer.Type;
 //#endregion
-export { OwnerThreadPage as $, WorkflowCallRefusal as $t, ConnectionName as A, WorkflowStartState as An, SignInDestination as At, GateOwn as B, isRef0Path as Bn, TrackThread as Bt, ConnectAgent as C, WorkflowPasskeyState as Cn, SandboxPushAnswer as Ct, ConnectionCallAnswer as D, WorkflowPullRequestOpen as Dn, SentryOrg as Dt, ConnectionCall as E, WorkflowPullRequestAnswer as En, SecretHash as Et, CredentialView as F, commandLine as Fn, StatementView as Ft, LiveTicketRequest as G, WorkflowActionAnswer as Gt, Harness as H, projectParts as Hn, VersionFile as Ht, EndpointName as I, connectEndpoint as In, ThreadId as It, MirrorChoice as J, WorkflowAskClosed as Jt, LiveTrackName as K, WorkflowAnswerer as Kt, EventRunInput as L, encodeSecret as Ln, ThreadStage as Lt, ConsentAsked as M, WorkflowThreadStart as Mn, SocketUrl as Mt, ConsentClient as N, WorkflowTrigger as Nn, StartActor as Nt, ConnectionChanged as O, WorkflowRequestRefusal as On, SentryRegion as Ot, ConsentProject as P, WrittenProject as Pn, StartRun as Pt, OwnerName as Q, WorkflowCallInput as Qt, ForkAnswer as R, hookTokenPrefix as Rn, TrackClosed as Rt, ClientGranted as S, WorkflowPasskeyRead as Sn, SandboxPush as St, ConnectableAgent as T, WorkflowPreview as Tn, ScopeAction as Tt, ImportFailure as U, repoNameKey as Un, Welcome as Ut, GetIssueInput as V, liveSocketUrl as Vn, TypedApprovalCode as Vt, LiveTicket as W, surfaceOf as Wn, WorkflowAction as Wt, MirrorView as X, WorkflowCallAnswer as Xt, MirrorEntry as Y, WorkflowCall as Yt, OwnerId as Z, WorkflowCallEnded as Zt, CheckOwn as _, WorkflowFilters as _n, RepoView as _t, Api as a, WorkflowCheckResults as an, PasskeyFrom as at, CheckTreeEntry as b, WorkflowPasskeyAsked as bn, SandboxOpen as bt, ApprovalId as c, WorkflowCheckRunEnded as cn, PreviewEcho as ct, ApprovalView as d, WorkflowCheckStates as dn, ProjectTrackMessage as dt, WorkflowCallRefused as en, OwnerThreadView as et, AttachmentFailed as f, WorkflowCheckStatesAnswer as fn, RanOf as ft, CheckOn as g, WorkflowEvent as gn, RepoUrl as gt, ChangeAuthor as h, WorkflowConnections as hn, RepoName as ht, AgentView as i, WorkflowCheckRefused as in, PasskeyCreationOptions as it, ConnectionView as j, WorkflowText as jn, SignedIn as jt, ConnectionKind as k, WorkflowStartEnded as kn, SentryToken as kt, ApprovalPreview as l, WorkflowCheckStart as ln, PreviewUnavailable as lt, Authorization as m, WorkflowComment as mn, Ref0Owned as mt, AgentPermissionChoice as n, WorkflowCalledStateAnswer as nn, PasskeyAsserted as nt, ApiOrigin as o, WorkflowCheckResultsAnswer as on, PasskeyRefusal as ot, AttachmentRequestView as p, WorkflowCheckWhere as pn, ReadEvent as pt, MachineConnected as q, WorkflowAsk as qt, AgentPermissionSetting as r, WorkflowCheckRefusal as rn, PasskeyCreated as rt, ApprovalAnswer as s, WorkflowCheckRun as sn, PasskeyRequestOptions as st, AgentHandle as t, WorkflowCalledState as tn, OwnerTrackMessage as tt, ApprovalState as u, WorkflowCheckStartAnswer as un, ProjectName as ut, CheckRunError as v, WorkflowOwn as vn, SandboxExec as vt, ConnectChosen as w, WorkflowPermissions as wn, SandboxSize as wt, ClientAccess as x, WorkflowPasskeyEnded as xn, SandboxOpenAnswer as xt, CheckRunParams as y, WorkflowPasskeyAsk as yn, SandboxExecAnswer as yt, ForkCreate as z, hookUrl as zn, TrackSession as zt };
-//# sourceMappingURL=index-CJGX88qF.d.mts.map
+export { MirrorEntry as $, WorkflowAskClosed as $t, ConnectionCallAnswer as A, WorkflowPreview as An, ScopeAction as At, EventRunInput as B, commandLine as Bn, StatementView as Bt, ConnectAgent as C, WorkflowOwn as Cn, SandboxExec as Ct, ConnectOptions as D, WorkflowPasskeyRead as Dn, SandboxPush as Dt, ConnectFolderOption as E, WorkflowPasskeyEnded as En, SandboxOpenAnswer as Et, ConsentAsked as F, WorkflowStartState as Fn, SignInDestination as Ft, GetIssueInput as G, isRef0Path as Gn, TrackThread as Gt, ForkAnswer as H, encodeSecret as Hn, ThreadStage as Ht, ConsentClient as I, WorkflowText as In, SignedIn as It, LiveTicket as J, repoNameKey as Jn, Welcome as Jt, Harness as K, liveSocketUrl as Kn, TypedApprovalCode as Kt, ConsentProject as L, WorkflowThreadStart as Ln, SocketUrl as Lt, ConnectionKind as M, WorkflowPullRequestOpen as Mn, SentryOrg as Mt, ConnectionName as N, WorkflowRequestRefusal as Nn, SentryRegion as Nt, ConnectableAgent as O, WorkflowPasskeyState as On, SandboxPushAnswer as Ot, ConnectionView as P, WorkflowStartEnded as Pn, SentryToken as Pt, MirrorChoice as Q, WorkflowAsk as Qt, CredentialView as R, WorkflowTrigger as Rn, StartActor as Rt, ClientGranted as S, WorkflowFilters as Sn, RequestFolder as St, ConnectFolderChoices as T, WorkflowPasskeyAsked as Tn, SandboxOpen as Tt, ForkCreate as U, hookTokenPrefix as Un, TrackClosed as Ut, FoldersConnected as V, connectEndpoint as Vn, ThreadId as Vt, GateOwn as W, hookUrl as Wn, TrackSession as Wt, LiveTrackName as X, WorkflowActionAnswer as Xt, LiveTicketRequest as Y, surfaceOf as Yn, WorkflowAction as Yt, MachineConnected as Z, WorkflowAnswerer as Zt, CheckOwn as _, WorkflowCheckStatesAnswer as _n, ReadEvent as _t, Api as a, WorkflowCallRefused as an, OwnerTrackMessage as at, CheckTreeEntry as b, WorkflowConnections as bn, RepoUrl as bt, ApprovalId as c, WorkflowCheckRefusal as cn, PasskeyCreationOptions as ct, ApprovalView as d, WorkflowCheckResultsAnswer as dn, PasskeyRequestOptions as dt, WorkflowCall as en, MirrorView as et, AttachmentFailed as f, WorkflowCheckRun as fn, PreviewEcho as ft, CheckOn as g, WorkflowCheckStates as gn, RanOf as gt, ChangeAuthor as h, WorkflowCheckStartAnswer as hn, ProjectTrackMessage as ht, AgentView as i, WorkflowCallRefusal as in, OwnerThreadView as it, ConnectionChanged as j, WorkflowPullRequestAnswer as jn, SecretHash as jt, ConnectionCall as k, WorkflowPermissions as kn, SandboxSize as kt, ApprovalPreview as l, WorkflowCheckRefused as ln, PasskeyFrom as lt, Authorization as m, WorkflowCheckStart as mn, ProjectName as mt, AgentPermissionChoice as n, WorkflowCallEnded as nn, OwnerName as nt, ApiOrigin as o, WorkflowCalledState as on, PasskeyAsserted as ot, AttachmentRequestView as p, WorkflowCheckRunEnded as pn, PreviewUnavailable as pt, ImportFailure as q, projectParts as qn, VersionFile as qt, AgentPermissionSetting as r, WorkflowCallInput as rn, OwnerThreadPage as rt, ApprovalAnswer as s, WorkflowCalledStateAnswer as sn, PasskeyCreated as st, AgentHandle as t, WorkflowCallAnswer as tn, OwnerId as tt, ApprovalState as u, WorkflowCheckResults as un, PasskeyRefusal as ut, CheckRunError as v, WorkflowCheckWhere as vn, Ref0Owned as vt, ConnectChosen as w, WorkflowPasskeyAsk as wn, SandboxExecAnswer as wt, ClientAccess as x, WorkflowEvent as xn, RepoView as xt, CheckRunParams as y, WorkflowComment as yn, RepoName as yt, EndpointName as z, WrittenProject as zn, StartRun as zt };
+//# sourceMappingURL=index-Vb8-1Zk-.d.mts.map