@roamcode.ai/server 1.0.23 → 1.1.0

package/dist/index.d.ts

@@ -1,8 +1,9 @@
 import * as better_sqlite3 from 'better-sqlite3';
 import { FastifyInstance } from 'fastify';
+import WebSocket from 'ws';
+import { z, ZodType } from 'zod';
 import { spawn, ChildProcess, SpawnOptions } from 'node:child_process';
 import { EventEmitter } from 'node:events';
-import { ZodType } from 'zod';
 
 interface ServerConfig {
     claudeBin: string;
@@ -138,6 +139,12 @@ declare function assertConfigAllowsStart(cfg: ServerRuntimeConfig): void;
 declare function extractBearerToken(authorizationHeader: string | undefined): string | undefined;
 interface AuthGateOptions {
     token?: string;
+    /**
+     * Optional verifier for independently revocable credentials (for example per-device tokens). It
+     * receives the presented plaintext once; implementations should persist only a digest. A verifier
+     * failure is treated as an invalid credential and can never take the server down.
+     */
+    verifyCredential?: (token: string) => boolean;
     /** Consecutive failures from one client before it is locked out. Default 10. */
     maxFailures?: number;
     /** Lockout duration in ms. Default 60000. */
@@ -181,6 +188,7 @@ declare class AuthGate {
     private readonly lockoutMs;
     private readonly graceMs;
     private readonly now;
+    private readonly verifyCredential?;
     private readonly clients;
     constructor(opts: AuthGateOptions);
     check(presentedToken: string | undefined, clientKey: string): AuthCheckResult;
@@ -193,6 +201,10 @@ declare class AuthGate {
      * slate is correct (and avoids leaving a client locked out against a token that no longer exists).
      */
     rotateToken(newToken: string): void;
+    /** True only for the current host recovery credential (never a device key or grace token). */
+    isCurrentHostToken(presentedToken: string | undefined): boolean;
+    /** Security reset: replace the host credential immediately, with no previous-token grace window. */
+    resetToken(newToken: string): void;
     /** Drop entries whose lockout has expired and whose failure count is 0 — keeps the map bounded. */
     private sweepExpired;
     /** TEST ONLY: number of tracked clients currently locked (lockedUntil in the future). */
@@ -319,7 +331,58 @@ declare class FsService {
     pruneOlderThan(target: string, maxAgeMs: number, now?: number, recursive?: boolean): Promise<number>;
 }
 
-type ProviderId = "claude" | "codex";
+declare const ADAPTER_CONTRACT_VERSION: 1;
+declare const adapterCapabilityNames: readonly ["probe", "launch", "resume", "state", "identity", "metadata", "usage", "login", "attachments", "cleanup"];
+type AdapterCapabilityName = (typeof adapterCapabilityNames)[number];
+type AdapterStateAuthority = "native-events" | "runtime-signals" | "pane-heuristics";
+interface AdapterManifestV1 {
+    schemaVersion: typeof ADAPTER_CONTRACT_VERSION;
+    id: string;
+    version: string;
+    displayName: string;
+    platforms: Array<"darwin" | "linux">;
+    resumeIdentity: "optional" | "required" | "unsupported";
+    capabilities: Record<AdapterCapabilityName, boolean>;
+    stateAuthority: AdapterStateAuthority[];
+    /** JSON Schema for the adapter-owned launch options. */
+    optionSchema: Record<string, unknown>;
+}
+declare class AdapterManifestError extends Error {
+    constructor(message: string);
+}
+/** The supported, bounded JSON Schema subset shared by the server validator, generated UI, and OpenAPI. */
+declare function validateAdapterOptionSchema(value: unknown): Record<string, unknown>;
+declare function validateAdapterManifest(value: unknown): AdapterManifestV1;
+/** Validate and freeze the public metadata at the adapter boundary before any lifecycle code can run. */
+declare function defineAdapterManifest(value: AdapterManifestV1): Readonly<AdapterManifestV1>;
+declare function publicAdapterDescriptor(manifest: AdapterManifestV1, source: "built-in" | "installed"): {
+    id: string;
+    displayName: string;
+    version: string;
+    schemaVersion: 1;
+    source: "built-in" | "installed";
+    enabled: boolean;
+    platforms: ("darwin" | "linux")[];
+    resumeIdentity: "optional" | "required" | "unsupported";
+    capabilities: {
+        state: boolean;
+        probe: boolean;
+        launch: boolean;
+        resume: boolean;
+        identity: boolean;
+        metadata: boolean;
+        usage: boolean;
+        login: boolean;
+        attachments: boolean;
+        cleanup: boolean;
+    };
+    stateAuthority: AdapterStateAuthority[];
+    optionSchema: Record<string, unknown>;
+};
+
+/** Public adapter identity. Built-ins are ordinary ids under the same contract; third parties are not
+ * forced through a source-code union update. Runtime validation is owned by ProviderRegistry. */
+type ProviderId = string;
 interface ProviderAvailability {
     terminalAvailable: boolean;
     metadataAvailable: boolean;
@@ -350,7 +413,22 @@ type CodexSessionOptions = {
     dangerouslyBypassApprovalsAndSandbox?: boolean;
     addDirs?: string[];
 };
-type ProviderSessionOptions = ClaudeSessionOptions | CodexSessionOptions;
+interface ProviderSessionOptions {
+    provider: ProviderId;
+    model?: string;
+    effort?: string;
+    reasoningEffort?: string;
+    permissionMode?: ClaudeSessionOptions["permissionMode"];
+    dangerouslySkip?: boolean;
+    sandbox?: CodexSessionOptions["sandbox"];
+    approvalPolicy?: CodexSessionOptions["approvalPolicy"];
+    profile?: string;
+    webSearch?: boolean;
+    dangerouslyBypassApprovalsAndSandbox?: boolean;
+    addDirs?: string[];
+    legacyArgs?: string[];
+    [key: string]: unknown;
+}
 type LaunchIntent = "fresh" | "resume";
 interface ProcessSpec {
     executable: string;
@@ -399,9 +477,11 @@ interface ProviderRuntimeMetadata {
     effort?: string;
 }
 interface AgentProvider {
+    /** Exact public, versioned adapter contract. Optional only for legacy in-process test doubles. */
+    readonly manifest?: Readonly<AdapterManifestV1>;
     readonly id: ProviderId;
     readonly displayName: string;
-    readonly resumeIdentity: "optional" | "required";
+    readonly resumeIdentity: "optional" | "required" | "unsupported";
     probe(): Promise<ProviderAvailability>;
     buildProcess(context: ProviderProcessContext): Promise<ProcessSpec>;
     /** Stateful parsers must be created per spawned process; providers are registry singletons. */
@@ -413,6 +493,10 @@ interface AgentProvider {
     runtimeMetadata?(pane: string): ProviderRuntimeMetadata | undefined;
     cleanup(paths: readonly string[]): void;
 }
+/** Installable and built-in adapters must implement this strict public shape. */
+interface ProviderAdapterV1 extends AgentProvider {
+    readonly manifest: Readonly<AdapterManifestV1>;
+}
 
 interface SessionDefaults {
     /** The provider used by the most recently created session. Absent only for legacy saved documents. */
@@ -480,6 +564,7 @@ interface StoredSessionBase {
 }
 interface StoredClaudeSession extends StoredSessionBase {
     provider: "claude";
+    externalAdapter?: never;
     dangerouslySkip: boolean;
     /** The USER-chosen spawn flags the session was created with (`--model`/`--effort`/`--permission-mode`/
      *  `--dangerously-skip-permissions`/`--add-dir …`) — everything EXCEPT the ephemeral per-session
@@ -497,13 +582,24 @@ interface StoredIntegrationStatus {
 }
 interface StoredCodexSession extends StoredSessionBase {
     provider: "codex";
+    externalAdapter?: never;
     launchOptions: CodexSessionOptions;
     providerSessionId?: string;
     integrationStatus?: StoredIntegrationStatus;
     dangerouslySkip?: never;
     spawnArgs?: never;
 }
-type StoredSession = StoredClaudeSession | StoredCodexSession;
+interface StoredExternalSession extends StoredSessionBase {
+    provider: ProviderId;
+    /** Discriminator that keeps additive third-party rows separate from rollback-readable built-in tables. */
+    externalAdapter: true;
+    launchOptions: ProviderSessionOptions;
+    providerSessionId?: string;
+    integrationStatus?: StoredIntegrationStatus;
+    dangerouslySkip?: never;
+    spawnArgs?: never;
+}
+type StoredSession = StoredClaudeSession | StoredCodexSession | StoredExternalSession;
 /** How a store is actually backed: "sqlite" (durable) or "memory-fallback" (the native module failed to
  *  load — NOT durable across restarts). Surfaced so start.ts can warn loudly + /diag can report it. */
 type StoreMode = "sqlite" | "memory-fallback";
@@ -594,6 +690,1514 @@ declare function resolveAccessToken(opts: ResolveAccessTokenOptions): {
     generated: boolean;
 };
 
+/** A pairing link is deliberately short-lived and can be claimed exactly once. */
+declare const PAIRING_TTL_MS: number;
+type DeviceScope = "direct" | "relay";
+interface DeviceInfo {
+    id: string;
+    name: string;
+    createdAt: number;
+    lastSeenAt: number;
+    scopes: DeviceScope[];
+    /** Pinned E2E relay signing identity. Public material only; the private key never leaves the device. */
+    relayIdentityFingerprint?: string;
+}
+interface DeviceRelayIdentity {
+    publicKey: string;
+    fingerprint: string;
+}
+declare class DevicePairingError extends Error {
+    readonly code: "INVALID_RELAY_IDENTITY";
+    constructor(code: "INVALID_RELAY_IDENTITY", message: string);
+}
+interface PairingTicket {
+    /** One-time capability carried by the pairing URL. Never persisted in plaintext. */
+    secret: string;
+    expiresAt: number;
+    /** Exact product surfaces the resulting device credential can reach. */
+    scopes: DeviceScope[];
+}
+/**
+ * Relay bootstrap pre-allocates both durable ids. The token is still inert until the one-use pairing
+ * capability is claimed, but carrying it in the URL fragment makes a dropped final response recoverable:
+ * the browser can reconnect with the same credential after the host committed the claim.
+ */
+interface RelayPairingTicket extends PairingTicket {
+    deviceId: string;
+    token: string;
+}
+interface DeviceEnrollment {
+    /** The per-device bearer credential. Returned once; only its SHA-256 digest is persisted. */
+    token: string;
+    device: DeviceInfo;
+}
+interface DeviceStore {
+    readonly mode: "sqlite" | "memory-fallback";
+    issuePairing(now?: number, scopes?: DeviceScope[]): PairingTicket;
+    claimPairing(secret: string, name: string, now?: number, relayIdentityPublicKey?: string): DeviceEnrollment | undefined;
+    issueRelayPairing(now?: number): RelayPairingTicket;
+    pendingRelayPairing(deviceId: string, now?: number): boolean;
+    claimRelayPairing(secret: string, token: string, name: string, relayIdentityPublicKey: string, now?: number): DeviceEnrollment | undefined;
+    /** Resolve a per-device bearer credential and best-effort touch its last-seen time. */
+    authenticate(token: string, now?: number, requiredScope?: DeviceScope): DeviceInfo | undefined;
+    relayIdentity(id: string): DeviceRelayIdentity | undefined;
+    list(): DeviceInfo[];
+    rename(id: string, name: string): DeviceInfo | undefined;
+    revoke(id: string): boolean;
+    revokeAll(): number;
+    close(): void;
+}
+interface OpenDeviceStoreOptions {
+    /** SQLite file path. ":memory:" uses an in-process DB. */
+    dbPath: string;
+    generateSecret?: () => string;
+    generateToken?: () => string;
+    generateId?: () => string;
+}
+declare function normalizeDeviceScopes(value: unknown): DeviceScope[] | undefined;
+/** Keep device labels useful in UI while refusing control characters and unbounded payloads. */
+declare function normalizeDeviceName(value: unknown): string | undefined;
+declare function openDeviceStore(opts: OpenDeviceStoreOptions): DeviceStore;
+
+declare const INPUT_LEASE_TTL_MS = 30000;
+type InputLeaseActorType = "device" | "host" | "local" | "relay";
+interface InputLeasePrincipal {
+    actorType: InputLeaseActorType;
+    actorId: string;
+    label: string;
+}
+interface InputLease {
+    id: string;
+    sessionId: string;
+    holderId: string;
+    actorType: InputLeaseActorType;
+    actorId: string;
+    label: string;
+    acquiredAt: number;
+    renewedAt: number;
+    expiresAt: number;
+    revision: number;
+}
+type InputLeaseEvent = {
+    type: "granted";
+    lease: InputLease;
+} | {
+    type: "renewed";
+    lease: InputLease;
+} | {
+    type: "released" | "expired" | "revoked";
+    lease: InputLease;
+} | {
+    type: "taken-over";
+    lease: InputLease;
+    previous: InputLease;
+};
+type InputLeaseAcquireResult = {
+    status: "granted" | "owned";
+    lease: InputLease;
+} | {
+    status: "denied";
+    current: InputLease;
+};
+interface InputLeaseCoordinatorOptions {
+    ttlMs?: number;
+    now?: () => number;
+    generateId?: () => string;
+    scheduleExpiry?: boolean;
+    onEvent?: (event: InputLeaseEvent) => void;
+}
+/**
+ * Coordinates the one mutable terminal input stream shared by many read-only observers.
+ *
+ * Leases intentionally live in memory: a host restart invalidates every connection and therefore every holder.
+ * Durable audit is supplied by the caller through onEvent. Expiry, release, and confirmed takeover are explicit;
+ * merely sending input can never acquire or steal ownership.
+ */
+declare class InputLeaseCoordinator {
+    private readonly leases;
+    private readonly listeners;
+    private readonly timers;
+    private readonly ttlMs;
+    private readonly now;
+    private readonly generateId;
+    private readonly scheduleExpiry;
+    private readonly onEvent?;
+    private revision;
+    constructor(options?: InputLeaseCoordinatorOptions);
+    acquire(sessionId: string, holderId: string, principal: InputLeasePrincipal): InputLeaseAcquireResult;
+    takeover(sessionId: string, holderId: string, principal: InputLeasePrincipal, confirmed: boolean, authorized?: boolean): InputLeaseAcquireResult;
+    renew(sessionId: string, holderId: string, leaseId: string): InputLease | undefined;
+    canWrite(sessionId: string, holderId: string, leaseId?: string): boolean;
+    release(sessionId: string, holderId: string, leaseId?: string): boolean;
+    releaseHolder(holderId: string): number;
+    revoke(sessionId: string): boolean;
+    revokeActor(actorType: InputLeaseActorType, actorId: string): number;
+    get(sessionId: string): InputLease | undefined;
+    subscribe(sessionId: string, listener: (event: InputLeaseEvent) => void): () => void;
+    close(): void;
+    private validate;
+    private current;
+    private renewExisting;
+    private remove;
+    private schedule;
+    private emit;
+}
+
+type TeamStoreMode = "sqlite" | "memory-fallback";
+type TeamMemberKind = "person" | "service";
+type TeamMemberStatus = "active" | "suspended" | "removed";
+type TeamRole = "viewer" | "operator" | "workspace-manager" | "extension-manager" | "policy-admin" | "organization-admin";
+type TeamScopeType = "team" | "host" | "workspace";
+type TeamPrincipalType = "device" | "host" | "local" | "relay";
+type TeamPermission = "team:read" | "sessions:read" | "sessions:operate" | "attention:read" | "attention:manage" | "presence:read" | "presence:write" | "workspaces:manage" | "extensions:manage" | "policy:manage" | "members:manage" | "audit:read" | "fleet:read";
+interface TeamRecord {
+    id: string;
+    name: string;
+    authorizationEnabled: boolean;
+    revision: number;
+    createdAt: number;
+    updatedAt: number;
+}
+interface TeamMember {
+    id: string;
+    displayName: string;
+    kind: TeamMemberKind;
+    status: TeamMemberStatus;
+    revision: number;
+    createdAt: number;
+    updatedAt: number;
+}
+interface TeamRoleBinding {
+    id: string;
+    memberId: string;
+    role: TeamRole;
+    scopeType: TeamScopeType;
+    scopeId?: string;
+    createdAt: number;
+}
+interface TeamPrincipalBinding {
+    actorType: TeamPrincipalType;
+    actorId: string;
+    memberId: string;
+    createdAt: number;
+}
+interface TeamAuthorizationResource {
+    hostId?: string;
+    workspaceId?: string;
+}
+interface TeamAuthorizationDecision {
+    allowed: boolean;
+    reason: "local-break-glass" | "not-enforced" | "unbound" | "inactive" | "role" | "missing-permission";
+    member?: TeamMember;
+    roles: TeamRole[];
+}
+interface TeamStore {
+    readonly mode: TeamStoreMode;
+    getTeam(): TeamRecord | null;
+    createTeam(input: {
+        name: string;
+        ownerName: string;
+        ownerPrincipal: {
+            actorType: TeamPrincipalType;
+            actorId: string;
+        };
+    }, now?: number): {
+        team: TeamRecord;
+        owner: TeamMember;
+    };
+    updateTeam(input: {
+        name?: string;
+        authorizationEnabled?: boolean;
+    }, expectedRevision: number, now?: number): TeamRecord;
+    listMembers(opts?: {
+        includeRemoved?: boolean;
+    }): TeamMember[];
+    getMember(id: string): TeamMember | undefined;
+    createMember(input: {
+        displayName: string;
+        kind?: TeamMemberKind;
+    }, now?: number): TeamMember;
+    updateMember(id: string, input: {
+        displayName?: string;
+        status?: TeamMemberStatus;
+    }, expectedRevision: number, now?: number): TeamMember | undefined;
+    listRoleBindings(memberId?: string): TeamRoleBinding[];
+    grantRole(input: {
+        memberId: string;
+        role: TeamRole;
+        scopeType?: TeamScopeType;
+        scopeId?: string;
+    }, now?: number): TeamRoleBinding;
+    revokeRole(id: string, now?: number): boolean;
+    listPrincipalBindings(memberId?: string): TeamPrincipalBinding[];
+    bindPrincipal(input: {
+        memberId: string;
+        actorType: TeamPrincipalType;
+        actorId: string;
+    }, now?: number): TeamPrincipalBinding;
+    unbindPrincipal(actorType: TeamPrincipalType, actorId: string, now?: number): boolean;
+    memberForPrincipal(actorType: TeamPrincipalType, actorId: string): TeamMember | undefined;
+    authorize(actorType: TeamPrincipalType, actorId: string, permission: TeamPermission, resource?: TeamAuthorizationResource): TeamAuthorizationDecision;
+    close(): void;
+}
+interface OpenTeamStoreOptions {
+    dbPath: string;
+    generateTeamId?: () => string;
+    generateMemberId?: () => string;
+    generateRoleId?: () => string;
+    loadDatabase?: () => typeof better_sqlite3;
+}
+declare class TeamRevisionConflictError extends Error {
+    readonly current: TeamRecord | TeamMember;
+    constructor(current: TeamRecord | TeamMember);
+}
+declare function openTeamStore(opts: OpenTeamStoreOptions): TeamStore;
+declare function teamRolePermissions(role: TeamRole): readonly TeamPermission[];
+declare function isTeamRole(value: unknown): value is TeamRole;
+declare function isTeamScopeType(value: unknown): value is TeamScopeType;
+
+declare const PRESENCE_TTL_MS = 45000;
+declare const PRESENCE_HEARTBEAT_MS = 15000;
+type PresenceMode = "viewing" | "operating";
+interface PresenceTarget {
+    hostId: string;
+    workspaceId?: string;
+    sessionId?: string;
+    agentId?: string;
+}
+interface PresenceRecord extends PresenceTarget {
+    id: string;
+    memberId?: string;
+    label: string;
+    mode: PresenceMode;
+    connectedAt: number;
+    lastSeenAt: number;
+    expiresAt: number;
+    revision: number;
+}
+type PresenceEvent = {
+    type: "joined" | "updated" | "left" | "expired";
+    presence: PresenceRecord;
+};
+interface PresenceHeartbeatInput extends PresenceTarget {
+    clientId: string;
+    mode: PresenceMode;
+    memberId?: string;
+}
+interface PresenceCoordinatorOptions {
+    ttlMs?: number;
+    now?: () => number;
+    generateId?: () => string;
+    maxRecords?: number;
+    maxPerActor?: number;
+    scheduleExpiry?: boolean;
+}
+/**
+ * Ephemeral, privacy-bounded presence. No IP, bearer credential, path, prompt, or terminal data is retained.
+ * Heartbeats expire cleanly after disconnect and are capped both globally and per authenticated actor.
+ */
+declare class PresenceCoordinator {
+    private readonly records;
+    private readonly listeners;
+    private readonly ttlMs;
+    private readonly now;
+    private readonly generateId;
+    private readonly maxRecords;
+    private readonly maxPerActor;
+    private readonly timer?;
+    private revision;
+    constructor(options?: PresenceCoordinatorOptions);
+    heartbeat(principal: InputLeasePrincipal, input: PresenceHeartbeatInput): PresenceRecord;
+    list(filter?: Partial<PresenceTarget>): PresenceRecord[];
+    release(principal: Pick<InputLeasePrincipal, "actorType" | "actorId">, clientId: string): boolean;
+    releaseActor(principal: Pick<InputLeasePrincipal, "actorType" | "actorId">): number;
+    /**
+     * Input ownership is authoritative for the public "operating" label. When a lease ends or moves, keep the
+     * connected observer visible but immediately downgrade stale operating heartbeats instead of waiting for TTL.
+     */
+    downgradeOperating(principal: Pick<InputLeasePrincipal, "actorType" | "actorId">, sessionId: string): number;
+    subscribe(listener: (event: PresenceEvent) => void): () => void;
+    sweep(): number;
+    close(): void;
+    private enforceBounds;
+    private evict;
+    private publicRecord;
+    private emit;
+}
+
+declare const RELAY_PROTOCOL_VERSION: 1;
+declare const RELAY_HANDSHAKE_MAX_SKEW_MS: number;
+declare const RELAY_CHANNEL_MAX_AGE_MS: number;
+declare const RELAY_CHANNEL_MAX_FRAMES = 1000000;
+declare const RELAY_MAX_PLAINTEXT_BYTES: number;
+type RelayRole = "device" | "host";
+type RelayDirection = "device-to-host" | "host-to-device";
+type RelayFrameKind = "auth" | "rpc-request" | "rpc-response" | "stream-open" | "stream-data" | "stream-control" | "close";
+type RelayCryptoErrorCode = "INVALID_RELAY_IDENTITY" | "INVALID_RELAY_HELLO" | "RELAY_IDENTITY_MISMATCH" | "RELAY_SIGNATURE_INVALID" | "RELAY_HANDSHAKE_EXPIRED" | "RELAY_HANDSHAKE_MISMATCH" | "RELAY_FRAME_INVALID" | "RELAY_FRAME_OUT_OF_ORDER" | "RELAY_FRAME_AUTH_FAILED" | "RELAY_FRAME_TOO_LARGE" | "RELAY_KEY_ROTATION_REQUIRED" | "RELAY_CHANNEL_CLOSED";
+declare class RelayCryptoError extends Error {
+    readonly code: RelayCryptoErrorCode;
+    constructor(code: RelayCryptoErrorCode, message: string);
+}
+interface RelayIdentity {
+    /** Base64url-encoded SPKI DER public key. Safe to pin and exchange. */
+    publicKey: string;
+    /** Base64url-encoded PKCS#8 DER private key. Host persistence must use mode 0600. */
+    privateKey: string;
+    fingerprint: string;
+}
+interface RelayEphemeralKeyPair {
+    publicKey: string;
+    privateKey: string;
+}
+interface RelayHandshakeHello {
+    v: typeof RELAY_PROTOCOL_VERSION;
+    role: RelayRole;
+    routeId: string;
+    deviceId: string;
+    sessionId: string;
+    issuedAt: number;
+    nonce: string;
+    ephemeralPublicKey: string;
+    identityFingerprint: string;
+    signature: string;
+}
+interface RelayEncryptedFrame {
+    v: typeof RELAY_PROTOCOL_VERSION;
+    sessionId: string;
+    seq: string;
+    kind: RelayFrameKind;
+    ciphertext: string;
+}
+interface RelayChannelOptions {
+    role: RelayRole;
+    localEphemeral: RelayEphemeralKeyPair;
+    deviceHello: RelayHandshakeHello;
+    hostHello: RelayHandshakeHello;
+    deviceIdentityPublicKey: string;
+    hostIdentityPublicKey: string;
+    now?: () => number;
+    maxAgeMs?: number;
+    maxFrames?: number;
+}
+declare function relayIdentityFingerprint(publicKey: string): string;
+declare function generateRelayIdentity(): RelayIdentity;
+/** Validates both key encodings and proves that the persisted private key belongs to the advertised identity. */
+declare function validateRelayIdentity(value: unknown): RelayIdentity;
+declare function generateRelayEphemeralKeyPair(): RelayEphemeralKeyPair;
+declare function createRelayHandshakeHello(input: {
+    role: RelayRole;
+    routeId: string;
+    deviceId: string;
+    sessionId?: string;
+    identity: RelayIdentity;
+    ephemeral?: RelayEphemeralKeyPair;
+    nonce?: Uint8Array;
+    issuedAt?: number;
+}): {
+    hello: RelayHandshakeHello;
+    ephemeral: RelayEphemeralKeyPair;
+};
+declare function verifyRelayHandshakeHello(hello: RelayHandshakeHello, expected: {
+    role: RelayRole;
+    routeId: string;
+    deviceId: string;
+    sessionId: string;
+    identityPublicKey: string;
+    now?: number;
+    maxSkewMs?: number;
+}): void;
+/** Small exported primitive used to pin RFC 5869 test vectors independently of the handshake. */
+declare function hkdfSha256(input: Uint8Array, salt: Uint8Array, info: Uint8Array, length: number): Buffer;
+declare class RelayCipherState {
+    readonly sessionId: string;
+    readonly role: RelayRole;
+    private readonly sendKey;
+    private readonly receiveKey;
+    private readonly sendBaseNonce;
+    private readonly receiveBaseNonce;
+    private readonly now;
+    private readonly maxAgeMs;
+    private readonly maxFrames;
+    private sendSequence;
+    private receiveSequence;
+    private closed;
+    private readonly createdAt;
+    private readonly sendDirection;
+    private readonly receiveDirection;
+    constructor(sessionId: string, role: RelayRole, sendKey: Buffer, receiveKey: Buffer, sendBaseNonce: Buffer, receiveBaseNonce: Buffer, now: () => number, maxAgeMs: number, maxFrames: number);
+    encrypt(kind: RelayFrameKind, plaintext: Uint8Array): RelayEncryptedFrame;
+    decrypt(frame: RelayEncryptedFrame): Buffer;
+    needsRotation(): boolean;
+    sequences(): {
+        send: string;
+        receive: string;
+    };
+    close(): void;
+    private assertOpen;
+    private assertKind;
+}
+declare function establishRelayChannel(options: RelayChannelOptions): RelayCipherState;
+
+interface RelayIdentityStoreOptions {
+    dataDir: string;
+    generate?: () => RelayIdentity;
+    now?: () => number;
+}
+interface DurableRelayIdentity {
+    identity: RelayIdentity;
+    createdAt: number;
+    path: string;
+    generated: boolean;
+}
+/** Loads one stable host identity or creates it once without allowing concurrent processes to overwrite it. */
+declare function loadOrCreateRelayIdentity(options: RelayIdentityStoreOptions): DurableRelayIdentity;
+
+type RelayStoreMode = "sqlite" | "memory";
+interface RelayRouteRecord {
+    id: string;
+    label: string;
+    hostCredentialHash: string;
+    ownerAccountId?: string;
+    createdAt: number;
+    updatedAt: number;
+}
+interface RelayDeviceRouteRecord {
+    routeId: string;
+    deviceId: string;
+    credentialHash: string;
+    createdAt: number;
+    updatedAt: number;
+    /** Bootstrap credentials expire unless the host promotes the device after the E2E pairing claim. */
+    expiresAt?: number;
+}
+interface PublicRelayRouteRecord {
+    id: string;
+    label: string;
+    deviceCount: number;
+    createdAt: number;
+    updatedAt: number;
+}
+interface RelayRouteStore {
+    readonly mode: RelayStoreMode;
+    createRoute(input: {
+        id?: string;
+        label: string;
+        hostCredentialHash: string;
+        ownerAccountId?: string;
+    }, now?: number): RelayRouteRecord;
+    getRoute(id: string): RelayRouteRecord | undefined;
+    listRoutes(now?: number): PublicRelayRouteRecord[];
+    listRoutesByOwner(ownerAccountId: string, now?: number): PublicRelayRouteRecord[];
+    countDevices(routeId: string, now?: number): number;
+    rotateHostCredential(routeId: string, credentialHash: string, now?: number): boolean;
+    deleteRoute(id: string): boolean;
+    authenticateHost(routeId: string, credential: string): boolean;
+    putDevice(input: {
+        routeId: string;
+        deviceId: string;
+        credentialHash: string;
+        expiresAt?: number;
+    }, now?: number): RelayDeviceRouteRecord;
+    getDevice(routeId: string, deviceId: string, now?: number): RelayDeviceRouteRecord | undefined;
+    authenticateDevice(routeId: string, deviceId: string, credential: string, now?: number): boolean;
+    revokeDevice(routeId: string, deviceId: string): boolean;
+    close(): void;
+}
+interface OpenRelayRouteStoreOptions {
+    dbPath: string;
+    generateRouteId?: () => string;
+    loadDatabase?: () => typeof better_sqlite3;
+}
+declare function relayCredentialHash(credential: string): string;
+declare function generateRelayCredential(prefix?: "rrh" | "rrd" | "rrp"): string;
+declare function openRelayRouteStore(options: OpenRelayRouteStoreOptions): RelayRouteStore;
+
+type RelayAccountStoreMode = "sqlite" | "memory";
+type RelayAccountStatus = "active" | "suspended" | "deleted";
+type RelayAccountPlan = "free" | "team" | "enterprise";
+interface RelayAccountRecord {
+    id: string;
+    label: string;
+    status: RelayAccountStatus;
+    plan: RelayAccountPlan;
+    maxRoutes: number;
+    maxDevicesPerRoute: number;
+    revision: number;
+    createdAt: number;
+    updatedAt: number;
+}
+interface CreateRelayAccountInput {
+    label: string;
+    credential: string;
+    plan?: RelayAccountPlan;
+    maxRoutes?: number;
+    maxDevicesPerRoute?: number;
+}
+interface UpdateRelayAccountInput {
+    label?: string;
+    status?: RelayAccountStatus;
+    plan?: RelayAccountPlan;
+    maxRoutes?: number;
+    maxDevicesPerRoute?: number;
+}
+interface RelayAccountStore {
+    readonly mode: RelayAccountStoreMode;
+    createAccount(input: CreateRelayAccountInput, now?: number): RelayAccountRecord;
+    getAccount(id: string): RelayAccountRecord | undefined;
+    listAccounts(options?: {
+        includeDeleted?: boolean;
+    }): RelayAccountRecord[];
+    authenticate(credential: string): RelayAccountRecord | undefined;
+    updateAccount(id: string, input: UpdateRelayAccountInput, expectedRevision: number, now?: number): RelayAccountRecord | undefined;
+    rotateCredential(id: string, credential: string, expectedRevision: number, now?: number): RelayAccountRecord | undefined;
+    close(): void;
+}
+interface OpenRelayAccountStoreOptions {
+    dbPath: string;
+    generateAccountId?: () => string;
+    loadDatabase?: () => typeof better_sqlite3;
+}
+declare class RelayAccountRevisionConflictError extends Error {
+    readonly current: RelayAccountRecord;
+    constructor(current: RelayAccountRecord);
+}
+declare function relayAccountCredentialHash(credential: string): string;
+declare function relayAccountCredentialLookup(credential: string): string;
+declare function generateRelayAccountCredential(): string;
+declare function openRelayAccountStore(options: OpenRelayAccountStoreOptions): RelayAccountStore;
+
+interface RelayDeviceProvisioner {
+    putDevice(deviceId: string, credentialHash: string, expiresAt?: number): Promise<void>;
+    revokeDevice(deviceId: string): Promise<void>;
+}
+interface RelayDeviceProvisionerOptions {
+    relayUrl: string;
+    routeId: string;
+    hostCredential: string;
+    request?: typeof globalThis.fetch;
+    timeoutMs?: number;
+}
+/** Host-authenticated provisioning uses HTTPS; routing credentials never appear in URLs or logs. */
+declare function createRelayDeviceProvisioner(options: RelayDeviceProvisionerOptions): RelayDeviceProvisioner;
+
+interface RelayPairingPackage {
+    v: 1;
+    label: string;
+    relayUrl: string;
+    routeId: string;
+    deviceId: string;
+    deviceCredential: string;
+    deviceToken: string;
+    pairingSecret: string;
+    expiresAt: number;
+    hostIdentityPublicKey: string;
+    hostIdentityFingerprint: string;
+}
+interface RelayPairingBootstrap {
+    appUrl: string;
+    label: string;
+    relayUrl: string;
+    routeId: string;
+    hostIdentityPublicKey: string;
+    hostIdentityFingerprint: string;
+    provisioner: RelayDeviceProvisioner;
+    generateDeviceCredential?: () => string;
+}
+declare function normalizeRelayAppUrl(value: string): string;
+declare function buildRelayPairingUrl(appUrl: string, pairing: RelayPairingPackage): string;
+
+declare const BLIND_RELAY_PROTOCOL_VERSION: 1;
+declare const BLIND_RELAY_DEFAULT_MAX_FRAME_BYTES = 1500000;
+declare const BLIND_RELAY_DEFAULT_MAX_QUEUE_BYTES = 4000000;
+declare const BLIND_RELAY_DEFAULT_MAX_CONNECTIONS_PER_ROUTE = 64;
+declare const BLIND_RELAY_DEFAULT_MAX_BYTES_PER_MINUTE: number;
+declare const BLIND_RELAY_DEFAULT_MAX_MESSAGES_PER_MINUTE = 12000;
+interface CreateBlindRelayOptions {
+    rootToken: string;
+    /** Previous provisioning capabilities accepted only during an explicit, bounded zero-downtime rotation window. */
+    previousRootTokens?: string[];
+    store?: RelayRouteStore;
+    /** Optional hosted control plane. Self-hosted root-only routing remains available without it. */
+    accountStore?: RelayAccountStore;
+    allowedOrigins?: string[];
+    handshakeTimeoutMs?: number;
+    idleTimeoutMs?: number;
+    maxFrameBytes?: number;
+    maxQueueBytes?: number;
+    maxConnectionsPerRoute?: number;
+    maxBytesPerMinute?: number;
+    maxMessagesPerMinute?: number;
+    now?: () => number;
+    generateChannelId?: () => string;
+}
+interface BlindRelayMetrics {
+    activeHosts: number;
+    activeDevices: number;
+    acceptedConnections: number;
+    rejectedConnections: number;
+    forwardedFrames: number;
+    forwardedBytes: number;
+    droppedFrames: number;
+}
+interface BlindRelayServer {
+    app: FastifyInstance;
+    store: RelayRouteStore;
+    accountStore?: RelayAccountStore;
+    metrics(): BlindRelayMetrics;
+}
+declare function createBlindRelayServer(options: CreateBlindRelayOptions): BlindRelayServer;
+
+interface StartedBlindRelay extends BlindRelayServer {
+    url: string;
+}
+declare function startBlindRelay(env?: NodeJS.ProcessEnv): Promise<StartedBlindRelay>;
+declare function isRelayDirectExecution(moduleUrl: string, argv1: string | undefined, embeddedContainerBuild?: boolean): boolean;
+
+/** RPC uses JSON inside an encrypted frame inside a base64 relay envelope. Larger data uses chunked streams. */
+declare const RELAY_RPC_MAX_BODY_BYTES: number;
+declare const RELAY_RPC_MAX_PATH_BYTES = 4096;
+type RelayRpcMethod = "GET" | "HEAD" | "POST" | "PUT" | "PATCH" | "DELETE";
+interface RelayRpcRequest {
+    id: string;
+    method: RelayRpcMethod;
+    path: string;
+    headers: Record<string, string>;
+    body?: Buffer;
+}
+interface RelayRpcResponse {
+    id: string;
+    status: number;
+    headers: Record<string, string>;
+    body?: string;
+}
+declare function parseRelayRpcRequest(value: unknown): RelayRpcRequest;
+declare function relayRpcResponse(input: {
+    id: string;
+    status: number;
+    headers: Record<string, string | string[] | number | undefined>;
+    body?: Uint8Array;
+}): RelayRpcResponse;
+
+type RelayHostStatus = "idle" | "connecting" | "online" | "reconnecting" | "stopped";
+interface RelayHostMetrics {
+    status: RelayHostStatus;
+    activeChannels: number;
+    acceptedChannels: number;
+    rejectedChannels: number;
+    completedRequests: number;
+    failedRequests: number;
+    reconnects: number;
+    activeTransfers: number;
+    completedTransfers: number;
+    failedTransfers: number;
+    streamedRequestBytes: number;
+    streamedResponseBytes: number;
+}
+interface RelayHostConnectorOptions {
+    relayUrl: string;
+    routeId: string;
+    hostCredential: string;
+    hostIdentity: RelayIdentity;
+    devices: DeviceStore;
+    dispatchRequest(token: string, request: RelayRpcRequest): Promise<RelayRpcResponse>;
+    openTerminal?: RelayTerminalOpener;
+    openHttp?: RelayHttpOpener;
+    WebSocketClass?: typeof WebSocket;
+    now?: () => number;
+    random?: () => number;
+    handshakeTimeoutMs?: number;
+    requestTimeoutMs?: number;
+    maxStreamRequestBytes?: number;
+    onStatus?: (status: RelayHostStatus) => void;
+    /** Promotes a five-minute broker bootstrap credential after the E2E pairing claim commits. */
+    promoteDevice?: (deviceId: string, credentialHash: string) => Promise<void>;
+}
+interface RelayTerminalOpenRequest {
+    streamId: string;
+    sessionId: string;
+    cols?: number;
+    rows?: number;
+    respawn?: "continue" | "fresh";
+}
+interface RelayTerminalHandlers {
+    onBinary(data: Uint8Array): void;
+    onControl(data: string): void;
+    onClose(code: number): void;
+}
+interface RelayTerminalBridge {
+    send(data: string): void;
+    close(): void;
+}
+type RelayTerminalOpener = (token: string, request: RelayTerminalOpenRequest, handlers: RelayTerminalHandlers) => Promise<RelayTerminalBridge>;
+interface RelayHttpOpenRequest {
+    streamId: string;
+    method: RelayRpcRequest["method"];
+    path: string;
+    headers: Record<string, string>;
+}
+interface RelayHttpResponseHead {
+    status: number;
+    headers: Record<string, string>;
+}
+interface RelayHttpHandlers {
+    onResponse(response: RelayHttpResponseHead): void | Promise<void>;
+    onData(data: Uint8Array): void | Promise<void>;
+    onEnd(): void | Promise<void>;
+    onError(error: Error): void;
+}
+interface RelayHttpBridge {
+    write(data: Uint8Array): Promise<void>;
+    end(): void;
+    close(): void;
+}
+type RelayHttpOpener = (token: string, request: RelayHttpOpenRequest, handlers: RelayHttpHandlers) => Promise<RelayHttpBridge>;
+interface RelayHostConnector {
+    start(): void;
+    stop(): Promise<void>;
+    waitUntilReady(timeoutMs?: number): Promise<void>;
+    closeDevice(deviceId: string): void;
+    metrics(): RelayHostMetrics;
+}
+declare function relayConnectUrl(raw: string): string;
+declare function createRelayHostConnector(options: RelayHostConnectorOptions): RelayHostConnector;
+
+interface RelayHostRuntimeConfig {
+    relayUrl: string;
+    routeId: string;
+    hostCredential: string;
+    hostIdentity: RelayIdentity;
+    /** Static PWA origin used only for one-use remote pairing links. */
+    appUrl?: string;
+    hostLabel: string;
+}
+interface PersistedRelayHostConfig {
+    version: 1;
+    relayUrl: string;
+    routeId: string;
+    hostCredential: string;
+    appUrl?: string;
+    hostLabel: string;
+}
+type RelayHostConfigInput = Omit<PersistedRelayHostConfig, "version">;
+declare function relayHostConfigPath(dataDir: string): string;
+declare function readRelayHostConfig(dataDir: string): PersistedRelayHostConfig | undefined;
+declare function writeRelayHostConfig(dataDir: string, input: RelayHostConfigInput): PersistedRelayHostConfig;
+declare function removeRelayHostConfig(dataDir: string): boolean;
+declare function resolveRelayHostConfig(env: NodeJS.ProcessEnv, dataDir: string): RelayHostRuntimeConfig | undefined;
+
+interface LoopbackRelayTerminalOptions {
+    baseUrl(): string | undefined;
+    issueTicket(token: string): Promise<string>;
+    WebSocketClass?: typeof WebSocket;
+    openTimeoutMs?: number;
+}
+declare function createLoopbackRelayTerminalOpener(options: LoopbackRelayTerminalOptions): RelayTerminalOpener;
+
+interface LoopbackRelayHttpOptions {
+    baseUrl(): string | undefined;
+    headers(token: string, requestHeaders: Record<string, string>): Record<string, string>;
+    idleTimeoutMs?: number;
+}
+/**
+ * Streams an authenticated relay request through the real loopback HTTP server. This deliberately traverses
+ * the normal auth, RBAC, rate-limit, idempotency, audit, multipart, and route hooks instead of calling file
+ * services out of band.
+ */
+declare function createLoopbackRelayHttpOpener(options: LoopbackRelayHttpOptions): RelayHttpOpener;
+
+declare const RELAY_WIRE_PROTOCOL_VERSION: 1;
+declare const RELAY_WIRE_MAX_ENVELOPE_BYTES = 1400000;
+type RelayWireEnvelope = {
+    v: 1;
+    t: "device-hello";
+    hello: RelayHandshakeHello;
+    identityPublicKey?: string;
+} | {
+    v: 1;
+    t: "host-hello";
+    hello: RelayHandshakeHello;
+} | {
+    v: 1;
+    t: "cipher";
+    frame: RelayEncryptedFrame;
+};
+declare function encodeRelayWireEnvelope(envelope: RelayWireEnvelope): string;
+declare function decodeRelayWireEnvelope(payload: unknown): RelayWireEnvelope;
+
+type PolicyStoreMode = "sqlite" | "memory-fallback";
+type ExtensionPolicyMode = "allow-integrity" | "signed-only" | "deny";
+type UpdatePolicyMode = "stable-only" | "deny";
+interface EnterprisePolicy {
+    enforcementEnabled: boolean;
+    allowedHostIds: string[] | null;
+    allowedWorkspaceIds: string[] | null;
+    allowedProviderIds: string[] | null;
+    allowDangerousProviderModes: boolean;
+    allowFileTransfer: boolean;
+    extensionMode: ExtensionPolicyMode;
+    allowRelay: boolean;
+    updateMode: UpdatePolicyMode;
+    revision: number;
+    createdAt: number;
+    updatedAt: number;
+}
+interface EnterprisePolicyUpdate {
+    enforcementEnabled?: boolean;
+    allowedHostIds?: string[] | null;
+    allowedWorkspaceIds?: string[] | null;
+    allowedProviderIds?: string[] | null;
+    allowDangerousProviderModes?: boolean;
+    allowFileTransfer?: boolean;
+    extensionMode?: ExtensionPolicyMode;
+    allowRelay?: boolean;
+    updateMode?: UpdatePolicyMode;
+}
+type EnterprisePolicyAction = "access" | "session.launch" | "file.transfer" | "extension.mutate" | "relay.access" | "update.mutate";
+interface EnterprisePolicyContext {
+    hostId: string;
+    workspaceId?: string;
+    providerId?: string;
+    dangerousProviderMode?: boolean;
+    extensionTrust?: "signed" | "integrity";
+    updateChannel?: "stable" | "beta" | "nightly";
+}
+interface EnterprisePolicyDecision {
+    allowed: boolean;
+    reason: "not-enforced" | "allowed" | "host-denied" | "workspace-denied" | "provider-denied" | "dangerous-mode-denied" | "file-transfer-denied" | "extension-denied" | "extension-signature-required" | "relay-denied" | "updates-denied" | "update-channel-denied";
+}
+interface PolicyStore {
+    readonly mode: PolicyStoreMode;
+    get(): EnterprisePolicy;
+    update(input: EnterprisePolicyUpdate, expectedRevision: number, now?: number): EnterprisePolicy;
+    close(): void;
+}
+interface OpenPolicyStoreOptions {
+    dbPath: string;
+    loadDatabase?: () => typeof better_sqlite3;
+    now?: number;
+}
+declare class EnterprisePolicyRevisionConflictError extends Error {
+    readonly current: EnterprisePolicy;
+    constructor(current: EnterprisePolicy);
+}
+declare function evaluateEnterprisePolicy(policy: EnterprisePolicy, action: EnterprisePolicyAction, context: EnterprisePolicyContext): EnterprisePolicyDecision;
+declare function openPolicyStore(options: OpenPolicyStoreOptions): PolicyStore;
+
+type PeerStoreMode = "sqlite" | "memory-fallback";
+type PeerAction = "read" | "send" | "wait" | "start" | "focus";
+type PeerStatus = "active" | "suspended";
+interface PeerRecord {
+    id: string;
+    label: string;
+    remoteHostId: string;
+    remoteVersion: string;
+    actions: PeerAction[];
+    allowedWorkspaceIds: string[] | null;
+    status: PeerStatus;
+    revision: number;
+    createdAt: number;
+    updatedAt: number;
+    lastVerifiedAt: number;
+}
+interface PeerConnection extends PeerRecord {
+    baseUrl: string;
+    credential: string;
+}
+interface CreatePeerInput {
+    label: string;
+    baseUrl: string;
+    credential: string;
+    remoteHostId: string;
+    remoteVersion: string;
+    actions?: PeerAction[];
+    allowedWorkspaceIds?: string[] | null;
+}
+interface UpdatePeerInput {
+    label?: string;
+    actions?: PeerAction[];
+    allowedWorkspaceIds?: string[] | null;
+    status?: PeerStatus;
+    remoteVersion?: string;
+    lastVerifiedAt?: number;
+}
+interface PeerStore {
+    readonly mode: PeerStoreMode;
+    list(): PeerRecord[];
+    get(id: string): PeerRecord | undefined;
+    connection(id: string): PeerConnection | undefined;
+    create(input: CreatePeerInput, now?: number): PeerRecord;
+    update(id: string, input: UpdatePeerInput, expectedRevision: number, now?: number): PeerRecord | undefined;
+    rotateCredential(id: string, input: {
+        credential: string;
+        remoteVersion: string;
+        lastVerifiedAt?: number;
+    }, expectedRevision: number, now?: number): PeerRecord | undefined;
+    remove(id: string): boolean;
+    close(): void;
+}
+interface OpenPeerStoreOptions {
+    dbPath: string;
+    generatePeerId?: () => string;
+    loadDatabase?: () => typeof better_sqlite3;
+}
+declare class PeerRevisionConflictError extends Error {
+    readonly current: PeerRecord;
+    constructor(current: PeerRecord);
+}
+declare function normalizePeerBaseUrl(value: unknown): string;
+declare function openPeerStore(options: OpenPeerStoreOptions): PeerStore;
+
+interface VerifiedPeerIdentity {
+    remoteHostId: string;
+    remoteVersion: string;
+    remoteLabel: string;
+    protocolVersion: number;
+}
+interface PeerJsonResponse {
+    status: number;
+    body: unknown;
+}
+declare class PeerRequestError extends Error {
+    readonly status?: number | undefined;
+    readonly remoteCode?: string | undefined;
+    constructor(message: string, status?: number | undefined, remoteCode?: string | undefined);
+}
+declare function requestPeerJson(connection: Pick<PeerConnection, "baseUrl" | "credential">, path: string, init?: {
+    method?: "GET" | "POST";
+    body?: unknown;
+    idempotencyKey?: string;
+    fetch?: typeof globalThis.fetch;
+    timeoutMs?: number;
+}): Promise<PeerJsonResponse>;
+declare function verifyPeerConnection(input: {
+    baseUrl: string;
+    credential: string;
+    localHostId: string;
+    fetch?: typeof globalThis.fetch;
+}): Promise<VerifiedPeerIdentity>;
+
+type CommandCenterStoreMode = "sqlite" | "memory-fallback";
+type WorkspaceKind = "directory" | "worktree";
+type AgentActivity = "blocked" | "working" | "done" | "idle" | "ended" | "unknown";
+type AttentionKind = "blocked" | "done" | "error" | "file" | "policy";
+type AttentionState = "open" | "acknowledged" | "snoozed" | "resolved";
+interface HostRecord {
+    id: string;
+    label: string;
+    createdAt: number;
+    updatedAt: number;
+}
+interface WorkspaceRecord {
+    id: string;
+    label: string;
+    cwd: string;
+    kind: WorkspaceKind;
+    sortOrder: number;
+    createdAt: number;
+    updatedAt: number;
+    archivedAt?: number;
+}
+interface SessionPlacement {
+    sessionId: string;
+    workspaceId: string;
+    agentId: string;
+    createdAt: number;
+}
+interface AgentRecord {
+    id: string;
+    sessionId: string;
+    workspaceId: string;
+    provider: string;
+    activity: AgentActivity;
+    createdAt: number;
+    updatedAt: number;
+}
+interface AttentionItem {
+    id: string;
+    workspaceId: string;
+    sessionId: string;
+    agentId: string;
+    kind: AttentionKind;
+    state: AttentionState;
+    title: string;
+    detail?: string;
+    urgency: number;
+    occurrenceCount: number;
+    createdAt: number;
+    updatedAt: number;
+    acknowledgedAt?: number;
+    snoozedUntil?: number;
+    resolvedAt?: number;
+}
+interface CommandEvent {
+    id: number;
+    type: string;
+    resourceType: string;
+    resourceId: string;
+    payload: Record<string, unknown>;
+    createdAt: number;
+}
+interface CommandLayoutEnvelope {
+    document: Record<string, unknown> | null;
+    revision: number;
+    updatedAt?: number;
+}
+declare class CommandCenterRevisionConflictError extends Error {
+    readonly current: CommandLayoutEnvelope;
+    constructor(current: CommandLayoutEnvelope);
+}
+interface CreateWorkspaceInput {
+    cwd: string;
+    label?: string;
+    kind?: WorkspaceKind;
+}
+interface UpdateWorkspaceInput {
+    label?: string;
+    sortOrder?: number;
+    archived?: boolean;
+}
+interface UpsertAgentInput {
+    sessionId: string;
+    workspaceId: string;
+    provider: string;
+    activity: AgentActivity;
+    createdAt: number;
+}
+interface RecordAttentionInput {
+    workspaceId: string;
+    sessionId: string;
+    agentId: string;
+    kind: AttentionKind;
+    title: string;
+    detail?: string;
+    urgency?: number;
+    /** Stable transition identity, e.g. `blocked:<sessionId>`. Only one unresolved item exists per key. */
+    dedupeKey: string;
+}
+interface CommandCenterStore {
+    readonly mode: CommandCenterStoreMode;
+    getHost(): HostRecord;
+    renameHost(label: string, now?: number): HostRecord;
+    listWorkspaces(opts?: {
+        includeArchived?: boolean;
+    }): WorkspaceRecord[];
+    getWorkspace(id: string): WorkspaceRecord | undefined;
+    createWorkspace(input: CreateWorkspaceInput, now?: number): WorkspaceRecord;
+    updateWorkspace(id: string, input: UpdateWorkspaceInput, now?: number): WorkspaceRecord | undefined;
+    ensureSession(sessionId: string, cwd: string, now?: number): SessionPlacement;
+    placementForSession(sessionId: string): SessionPlacement | undefined;
+    removeSession(sessionId: string, now?: number): void;
+    upsertAgent(input: UpsertAgentInput, now?: number): AgentRecord;
+    getAgent(id: string): AgentRecord | undefined;
+    listAgents(): AgentRecord[];
+    recordAttention(input: RecordAttentionInput, now?: number): AttentionItem;
+    listAttention(opts?: {
+        includeResolved?: boolean;
+        includeSnoozed?: boolean;
+        now?: number;
+    }): AttentionItem[];
+    acknowledgeAttention(id: string, now?: number): AttentionItem | undefined;
+    snoozeAttention(id: string, until: number, now?: number): AttentionItem | undefined;
+    resolveAttention(id: string, now?: number): AttentionItem | undefined;
+    resolveAttentionByDedupeKey(dedupeKey: string, now?: number): number;
+    markSessionViewed(sessionId: string, now?: number): number;
+    appendEvent(type: string, resourceType: string, resourceId: string, payload?: Record<string, unknown>, now?: number): CommandEvent;
+    listEvents(afterId?: number, limit?: number): CommandEvent[];
+    eventBounds(): {
+        earliest: number;
+        latest: number;
+    };
+    subscribeEvents(listener: (event: CommandEvent) => void): () => void;
+    getLayout(): CommandLayoutEnvelope;
+    putLayout(document: Record<string, unknown>, expectedRevision: number, now?: number): CommandLayoutEnvelope;
+    close(): void;
+}
+interface OpenCommandCenterStoreOptions {
+    dbPath: string;
+    hostLabel?: string;
+    generateHostId?: () => string;
+    generateWorkspaceId?: () => string;
+    generateAttentionId?: () => string;
+    /** Test/embedding seam; throwing selects the non-durable in-memory fallback. */
+    loadDatabase?: () => typeof better_sqlite3;
+}
+declare function normalizeLabel(value: unknown): string | undefined;
+declare function agentIdForSession(sessionId: string): string;
+declare function openCommandCenterStore(opts: OpenCommandCenterStoreOptions): CommandCenterStore;
+/** Exposed for API adapters and tests; one current RoamCode session owns one current agent. */
+declare const currentAgentIdForSession: typeof agentIdForSession;
+/** Re-exported validation keeps transport and stores on one label contract. */
+declare const normalizeCommandCenterLabel: typeof normalizeLabel;
+
+type WorktreeErrorCode = "WORKTREE_OUTSIDE_ROOT" | "WORKTREE_INVALID_REF" | "WORKTREE_NOT_FOUND" | "WORKTREE_NOT_REGISTERED" | "WORKTREE_MAIN_PROTECTED" | "WORKTREE_DIRTY" | "WORKTREE_EXISTS" | "WORKTREE_GIT_FAILED" | "WORKTREE_TIMEOUT";
+declare class WorktreeError extends Error {
+    readonly code: WorktreeErrorCode;
+    readonly statusCode: number;
+    constructor(code: WorktreeErrorCode, message: string, statusCode?: number);
+}
+interface WorktreeRecord {
+    path: string;
+    repositoryPath: string;
+    branch?: string;
+    head: string;
+    dirty: boolean;
+    changedFiles: number;
+    isMain: boolean;
+}
+interface CreateWorktreeInput {
+    repositoryPath: string;
+    path: string;
+    branch?: string;
+    baseRef?: string;
+}
+interface CreateWorktreeResult {
+    worktree: WorktreeRecord;
+    created: boolean;
+}
+interface WorktreeService {
+    inspect(path: string): Promise<WorktreeRecord>;
+    create(input: CreateWorktreeInput): Promise<CreateWorktreeResult>;
+    remove(path: string, force?: boolean): Promise<WorktreeRecord>;
+}
+interface CreateWorktreeServiceOptions {
+    fsRoot: string;
+    gitBin?: string;
+    timeoutMs?: number;
+    maxOutputBytes?: number;
+}
+declare function createWorktreeService(options: CreateWorktreeServiceOptions): WorktreeService;
+
+type ExtensionKind = "adapter" | "plugin";
+type ExtensionTrust = "signed" | "integrity";
+declare class ExtensionError extends Error {
+    readonly code: "EXTENSION_INVALID" | "EXTENSION_OUTSIDE_ROOT" | "EXTENSION_INTEGRITY_MISMATCH" | "EXTENSION_SIGNATURE_INVALID" | "EXTENSION_NOT_FOUND" | "EXTENSION_VERSION_NOT_FOUND" | "EXTENSION_ROLLBACK_UNAVAILABLE" | "EXTENSION_IN_USE" | "EXTENSION_PERMISSION_DENIED";
+    readonly statusCode: number;
+    constructor(code: "EXTENSION_INVALID" | "EXTENSION_OUTSIDE_ROOT" | "EXTENSION_INTEGRITY_MISMATCH" | "EXTENSION_SIGNATURE_INVALID" | "EXTENSION_NOT_FOUND" | "EXTENSION_VERSION_NOT_FOUND" | "EXTENSION_ROLLBACK_UNAVAILABLE" | "EXTENSION_IN_USE" | "EXTENSION_PERMISSION_DENIED", message: string, statusCode?: number);
+}
+declare const pluginPermissionSchema: z.ZodEnum<{
+    "notifications:write": "notifications:write";
+    "worktrees:write": "worktrees:write";
+    "ci:read": "ci:read";
+    "releases:read": "releases:read";
+    "events:read": "events:read";
+    "events:write": "events:write";
+}>;
+declare const pluginManifestSchema: z.ZodObject<{
+    schemaVersion: z.ZodLiteral<1>;
+    kind: z.ZodLiteral<"plugin">;
+    id: z.ZodString;
+    version: z.ZodString;
+    displayName: z.ZodString;
+    description: z.ZodString;
+    platforms: z.ZodArray<z.ZodEnum<{
+        darwin: "darwin";
+        linux: "linux";
+    }>>;
+    minimumRoamCodeVersion: z.ZodOptional<z.ZodString>;
+    permissions: z.ZodArray<z.ZodEnum<{
+        "notifications:write": "notifications:write";
+        "worktrees:write": "worktrees:write";
+        "ci:read": "ci:read";
+        "releases:read": "releases:read";
+        "events:read": "events:read";
+        "events:write": "events:write";
+    }>>;
+    actions: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodOptional<z.ZodString>;
+        entrypoint: z.ZodString;
+        args: z.ZodDefault<z.ZodArray<z.ZodString>>;
+        cwd: z.ZodDefault<z.ZodEnum<{
+            workspace: "workspace";
+            host: "host";
+            explicit: "explicit";
+        }>>;
+        timeoutMs: z.ZodDefault<z.ZodNumber>;
+        maxOutputBytes: z.ZodDefault<z.ZodNumber>;
+        permissions: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+            "notifications:write": "notifications:write";
+            "worktrees:write": "worktrees:write";
+            "ci:read": "ci:read";
+            "releases:read": "releases:read";
+            "events:read": "events:read";
+            "events:write": "events:write";
+        }>>>;
+    }, z.core.$strict>>;
+    eventHooks: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        event: z.ZodString;
+        actionId: z.ZodString;
+    }, z.core.$strict>>>;
+    settingsSchema: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    ui: z.ZodOptional<z.ZodObject<{
+        label: z.ZodString;
+        route: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+declare const adapterRuntimeSchema: z.ZodObject<{
+    executable: z.ZodString;
+    probeArgs: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    probeTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    launchArgs: z.ZodArray<z.ZodString>;
+    resumeArgs: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    env: z.ZodDefault<z.ZodArray<z.ZodEnum<{
+        HOME: "HOME";
+        PATH: "PATH";
+        LANG: "LANG";
+        LC_ALL: "LC_ALL";
+        TMPDIR: "TMPDIR";
+        SHELL: "SHELL";
+    }>>>;
+    workingPatterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    blockedPatterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    idlePatterns: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    identityPattern: z.ZodOptional<z.ZodString>;
+}, z.core.$strict>;
+type PluginPermission = z.infer<typeof pluginPermissionSchema>;
+type PluginManifestV1 = z.infer<typeof pluginManifestSchema>;
+type AdapterRuntimeV1 = z.infer<typeof adapterRuntimeSchema>;
+interface AdapterPackageManifestV1 {
+    schemaVersion: 1;
+    kind: "adapter";
+    adapter: AdapterManifestV1;
+    runtime: AdapterRuntimeV1;
+}
+type ExtensionManifestV1 = PluginManifestV1 | AdapterPackageManifestV1;
+interface ExtensionVersionRecord {
+    kind: ExtensionKind;
+    id: string;
+    version: string;
+    manifest: ExtensionManifestV1;
+    integrity: string;
+    trust: ExtensionTrust;
+    signerFingerprint?: string;
+    source: string;
+    installedAt: number;
+}
+interface InstalledExtension {
+    kind: ExtensionKind;
+    id: string;
+    enabled: boolean;
+    currentVersion: string;
+    previousVersion?: string;
+    updatedAt: number;
+    approvedPermissions: string[];
+    current: ExtensionVersionRecord;
+    versions: ExtensionVersionRecord[];
+}
+interface InstallExtensionInput {
+    sourceDirectory: string;
+    expectedIntegrity: string;
+    signature?: string;
+    publicKey?: string;
+    source?: string;
+    allowUnsigned?: boolean;
+}
+interface ExtensionManager {
+    readonly mode: "sqlite" | "memory-fallback";
+    list(kind?: ExtensionKind): InstalledExtension[];
+    get(kind: ExtensionKind, id: string): InstalledExtension | undefined;
+    packagePath(kind: ExtensionKind, id: string, version?: string): string;
+    verify(kind: ExtensionKind, id: string, version?: string): Promise<boolean>;
+    install(input: InstallExtensionInput): Promise<InstalledExtension>;
+    setEnabled(kind: ExtensionKind, id: string, enabled: boolean, approvedPermissions?: string[]): InstalledExtension;
+    rollback(kind: ExtensionKind, id: string): InstalledExtension;
+    uninstall(kind: ExtensionKind, id: string, options?: {
+        purgeState?: boolean;
+    }): Promise<boolean>;
+    close(): void;
+}
+interface OpenExtensionManagerOptions {
+    dbPath: string;
+    packagesDir: string;
+    fsRoot: string;
+    now?: () => number;
+    loadDatabase?: () => typeof better_sqlite3;
+}
+declare function inspectExtensionPackage(sourceDirectory: string, fsRoot: string): Promise<{
+    manifest: ExtensionManifestV1;
+    integrity: string;
+}>;
+declare function openExtensionManager(options: OpenExtensionManagerOptions): ExtensionManager;
+interface MarketplaceEntry {
+    kind: ExtensionKind;
+    id: string;
+    version: string;
+    displayName: string;
+    description: string;
+    trust: "verified" | "community" | "local";
+    compatibility: {
+        platforms: Array<"darwin" | "linux">;
+        minimumRoamCodeVersion?: string;
+    };
+    changelog?: string;
+    source: string;
+    integrity: string;
+    signerFingerprint?: string;
+    reportUrl?: string;
+}
+declare function parseMarketplaceIndex(value: unknown): MarketplaceEntry[];
+declare function searchMarketplace(entries: MarketplaceEntry[], query: string, platform?: NodeJS.Platform): MarketplaceEntry[];
+
+declare class PluginRuntimeError extends Error {
+    readonly code: "PLUGIN_NOT_FOUND" | "PLUGIN_DISABLED" | "PLUGIN_ACTION_NOT_FOUND" | "PLUGIN_PERMISSION_DENIED" | "PLUGIN_PATH_DENIED" | "PLUGIN_OUTPUT_LIMIT" | "PLUGIN_TIMEOUT" | "PLUGIN_FAILED";
+    readonly statusCode: number;
+    constructor(code: "PLUGIN_NOT_FOUND" | "PLUGIN_DISABLED" | "PLUGIN_ACTION_NOT_FOUND" | "PLUGIN_PERMISSION_DENIED" | "PLUGIN_PATH_DENIED" | "PLUGIN_OUTPUT_LIMIT" | "PLUGIN_TIMEOUT" | "PLUGIN_FAILED", message: string, statusCode?: number);
+}
+interface PluginRunInput {
+    pluginId: string;
+    actionId: string;
+    workspacePath?: string;
+    explicitCwd?: string;
+    context?: Record<string, unknown>;
+}
+interface PluginRunResult {
+    pluginId: string;
+    pluginVersion: string;
+    actionId: string;
+    status: "succeeded" | "failed";
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+    startedAt: number;
+    finishedAt: number;
+    truncated: false;
+}
+interface PluginAuditEvent {
+    pluginId: string;
+    pluginVersion: string;
+    actionId: string;
+    phase: "started" | "finished";
+    result?: "succeeded" | "failed";
+    exitCode?: number;
+    durationMs?: number;
+}
+interface CreatePluginRuntimeOptions {
+    extensions: ExtensionManager;
+    fsRoot: string;
+    now?: () => number;
+    audit?: (event: PluginAuditEvent) => void;
+}
+interface PluginRuntime {
+    run(input: PluginRunInput): Promise<PluginRunResult>;
+    hooksFor(eventType: string): Array<{
+        pluginId: string;
+        actionId: string;
+    }>;
+}
+declare function createPluginRuntime(options: CreatePluginRuntimeOptions): PluginRuntime;
+
+type ControlStoreMode = "sqlite" | "memory-fallback";
+type AuditActorType = "host" | "device" | "local" | "automation" | "plugin" | "system";
+type AuditResult = "success" | "denied" | "error";
+interface IdempotencyRecord {
+    actorId: string;
+    key: string;
+    fingerprint: string;
+    statusCode: number;
+    body: string;
+    createdAt: number;
+    expiresAt: number;
+}
+interface AuditRecord {
+    id: number;
+    actorType: AuditActorType;
+    actorId: string;
+    action: string;
+    targetType: string;
+    targetId?: string;
+    result: AuditResult;
+    metadata: Record<string, string | number | boolean | null>;
+    createdAt: number;
+    previousHash: string;
+    hash: string;
+}
+type AutomationTrigger = {
+    eventType: string;
+    resourceType?: string;
+};
+type AutomationAction = {
+    type: "acknowledge_attention";
+    target: "event-resource" | string;
+} | {
+    type: "resolve_attention";
+    target: "event-resource" | string;
+} | {
+    type: "snooze_attention";
+    target: "event-resource" | string;
+    durationMs: number;
+} | {
+    type: "emit_event";
+    eventType: string;
+    resourceType: string;
+    resourceId: string;
+};
+interface AutomationDefinition {
+    id: string;
+    name: string;
+    enabled: boolean;
+    trigger: AutomationTrigger;
+    action: AutomationAction;
+    permissions: string[];
+    createdAt: number;
+    updatedAt: number;
+}
+interface AutomationRun {
+    id: number;
+    automationId: string;
+    eventId?: number;
+    status: "succeeded" | "skipped" | "failed";
+    detail?: string;
+    createdAt: number;
+}
+interface CreateAutomationInput {
+    name: string;
+    enabled?: boolean;
+    trigger: AutomationTrigger;
+    action: AutomationAction;
+    permissions: string[];
+}
+interface UpdateAutomationInput {
+    name?: string;
+    enabled?: boolean;
+    trigger?: AutomationTrigger;
+    action?: AutomationAction;
+    permissions?: string[];
+}
+interface ControlStore {
+    readonly mode: ControlStoreMode;
+    getIdempotency(actorId: string, key: string, now?: number): IdempotencyRecord | undefined;
+    putIdempotency(record: IdempotencyRecord): void;
+    appendAudit(input: Omit<AuditRecord, "id" | "previousHash" | "hash">): AuditRecord;
+    listAudit(afterId?: number, limit?: number): AuditRecord[];
+    listAuditLatest(limit?: number): AuditRecord[];
+    verifyAuditChain(): {
+        valid: boolean;
+        count: number;
+        head: string;
+    };
+    listAutomations(): AutomationDefinition[];
+    getAutomation(id: string): AutomationDefinition | undefined;
+    createAutomation(input: CreateAutomationInput, now?: number): AutomationDefinition;
+    updateAutomation(id: string, input: UpdateAutomationInput, now?: number): AutomationDefinition | undefined;
+    removeAutomation(id: string): boolean;
+    recordAutomationRun(input: Omit<AutomationRun, "id">): AutomationRun;
+    listAutomationRuns(automationId?: string, limit?: number): AutomationRun[];
+    close(): void;
+}
+interface OpenControlStoreOptions {
+    dbPath: string;
+    generateAutomationId?: () => string;
+    loadDatabase?: () => typeof better_sqlite3;
+}
+declare function normalizeAutomationTrigger(value: unknown): AutomationTrigger | undefined;
+declare function normalizeAutomationAction(value: unknown): AutomationAction | undefined;
+declare function normalizeAutomationInput(value: unknown): CreateAutomationInput | undefined;
+/** Retain only coarse, bounded audit metadata; content- or credential-shaped fields are dropped. */
+declare function privacySafeAuditMetadata(value: Record<string, unknown> | undefined): Record<string, string | number | boolean | null>;
+declare function openControlStore(opts: OpenControlStoreOptions): ControlStore;
+declare const CONTROL_IDEMPOTENCY_TTL_MS: number;
+
 /**
  * Origin / CSWSH (cross-site WebSocket hijacking) guard for the WS upgrade and state-changing HTTP.
  *
@@ -724,6 +2328,11 @@ interface WsTicketStoreOptions {
     /** Injectable ticket generator for tests. Default: 32 CSPRNG bytes, base64url. */
     generate?: () => string;
 }
+interface WsTicketContext {
+    actorType: "device" | "host" | "local" | "relay";
+    actorId: string;
+    label: string;
+}
 /**
  * In-memory single-use ticket store. Deliberately NOT persisted: a ticket outliving a server restart
  * would defeat its 30s point, and the client just re-POSTs on reconnect. Expired entries are swept
@@ -731,20 +2340,25 @@ interface WsTicketStoreOptions {
  * a timer.
  */
 declare class WsTicketStore {
-    /** ticket → expiry (epoch ms). */
+    /** ticket → expiry + the authenticated principal that minted it. */
     private readonly tickets;
     private readonly ttlMs;
     private readonly now;
     private readonly generate;
     constructor(opts?: WsTicketStoreOptions);
     /** Mint a fresh single-use ticket. The response shape is exactly what POST /ws-ticket returns. */
-    issue(): {
+    issue(context?: WsTicketContext): {
         ticket: string;
         expiresInMs: number;
     };
     /** Consume a ticket: true exactly ONCE for a live ticket; false for unknown, expired, or already-used
      *  (the entry is deleted on first consume, so a replayed WS URL is rejected). */
     consume(ticket: string): boolean;
+    /** Consume once and recover the authenticated principal bound at issuance. The wrapper object makes a
+     *  context-free legacy/test ticket distinguishable from an invalid ticket. */
+    consumeWithContext(ticket: string): {
+        context?: WsTicketContext;
+    } | undefined;
     /** Drop expired entries so an unconsumed flood can't grow the map (lazy — no timer to leak). */
     private sweep;
     /** TEST ONLY: how many un-consumed tickets are currently held (post-sweep count). */
@@ -760,6 +2374,8 @@ interface PushSubscriptionRecord {
     auth: string;
     /** Optional session scope; undefined = subscribed to ALL sessions. */
     sessionId?: string;
+    /** Per-device credential that created this subscription. Revocation removes its push channel too. */
+    deviceId?: string;
     createdAt: number;
 }
 interface PushStore {
@@ -769,6 +2385,7 @@ interface PushStore {
         sessionId?: string;
     }): PushSubscriptionRecord[];
     remove(endpoint: string): void;
+    removeForDevice(deviceId: string): void;
     close(): void;
 }
 interface OpenPushStoreOptions {
@@ -1498,10 +3115,45 @@ declare function capturePane(opts: CaptureOptions): Promise<string>;
 
 declare class ProviderRegistry {
     private readonly byId;
+    private readonly manifests;
+    private readonly sources;
+    private readonly enabled;
     constructor(providers: readonly AgentProvider[]);
+    register(provider: AgentProvider, source?: "built-in" | "installed", enabled?: boolean): void;
+    setEnabled(id: ProviderId, enabled: boolean): void;
+    isEnabled(id: ProviderId): boolean;
+    source(id: ProviderId): "built-in" | "installed" | undefined;
+    unregisterInstalled(id: ProviderId): void;
     get(id: ProviderId): AgentProvider;
     list(): AgentProvider[];
+    listEnabled(): AgentProvider[];
+    manifest(id: ProviderId): Readonly<AdapterManifestV1>;
+    descriptors(): {
+        enabled: boolean;
+        id: string;
+        displayName: string;
+        version: string;
+        schemaVersion: 1;
+        source: "built-in" | "installed";
+        platforms: ("darwin" | "linux")[];
+        resumeIdentity: "optional" | "required" | "unsupported";
+        capabilities: {
+            state: boolean;
+            probe: boolean;
+            launch: boolean;
+            resume: boolean;
+            identity: boolean;
+            metadata: boolean;
+            usage: boolean;
+            login: boolean;
+            attachments: boolean;
+            cleanup: boolean;
+        };
+        stateAuthority: AdapterStateAuthority[];
+        optionSchema: Record<string, unknown>;
+    }[];
 }
+type ReturnTypeOfDescriptors = ReturnType<ProviderRegistry["descriptors"]>;
 
 interface CodexSpawnLease {
     readonly started: Promise<void>;
@@ -1643,6 +3295,11 @@ interface TerminalManagerDeps {
      * are). Same never-throw contract.
      */
     onFinished?: (id: string, wasAttached: boolean) => void;
+    /** Every semantic state transition, including ones observed while a browser is attached. Used by the
+     * command-center event/attention layer; a failure is isolated from terminal state. */
+    onActivityChanged?: (id: string, previous: PaneStatus, current: PaneStatus, attached: boolean) => void;
+    /** A client focused/attached this terminal. Done-unseen attention can become seen; blocked attention stays. */
+    onViewed?: (id: string) => void;
     /**
      * Capture a tmux session's CURRENT rendered pane as plain text (READ-ONLY). Injected for tests; in
      * production it defaults to a real `capture-pane -p` on {@link TMUX_SOCKET}. Drives {@link refreshActivity},
@@ -1655,15 +3312,8 @@ interface TerminalManagerDeps {
 type CreateTerminalOptions = {
     id: string;
     cwd: string;
-    provider: "claude";
-    options: ClaudeSessionOptions;
-    cols?: number;
-    rows?: number;
-} | {
-    id: string;
-    cwd: string;
-    provider: "codex";
-    options: CodexSessionOptions;
+    provider: ProviderId;
+    options: ProviderSessionOptions;
     cols?: number;
     rows?: number;
 };
@@ -1680,6 +3330,7 @@ declare class TerminalManager {
     private readonly providers;
     private attachConfig?;
     constructor(deps: TerminalManagerDeps);
+    private notifyActivityChanged;
     /** Late-bound (after listen(), which resolves the loopback port) — same config the chat SessionManager
      *  gets. When set, each terminal's claude is spawned with `--mcp-config` so send_image/send_file work. */
     setAttachConfig(attach: AttachSpawnOptions | undefined): void;
@@ -2125,8 +3776,24 @@ declare class CodexLatestService {
 
 interface CreateServerDeps {
     store?: SessionStore;
+    /** Durable per-device credentials + one-time pairing sessions. start.ts supplies a SQLite store. */
+    deviceStore?: DeviceStore;
+    /** Durable host/workspace/agent/attention/event state. start.ts supplies a SQLite store. */
+    commandStore?: CommandCenterStore;
+    /** Durable idempotency, privacy-safe audit, and automation definitions/runs. */
+    controlStore?: ControlStore;
+    /** Guarded git worktree lifecycle, confined to FS_ROOT and injectable for isolated tests. */
+    worktreeService?: WorktreeService;
+    /** Durable verified adapter/plugin package inventory. start.ts supplies a SQLite-backed manager. */
+    extensionManager?: ExtensionManager;
+    /** Bounded, permissioned plugin subprocess boundary. */
+    pluginRuntime?: PluginRuntime;
+    /** Optional immutable marketplace index; local extension installation never depends on it. */
+    marketplaceEntries?: MarketplaceEntry[];
     /** Absolute path to the built PWA (packages/web/dist). When set, the server also serves the UI. */
     webDir?: string;
+    /** Per-process boot identity returned as a response header for the out-of-process managed watchdog. */
+    healthInstanceId?: string;
     pushStore?: PushStore;
     /** VAPID public key exposed at GET /push/vapid for the browser subscription. */
     vapidPublicKey?: string;
@@ -2216,13 +3883,49 @@ interface CreateServerDeps {
      * store is built when omitted.
      */
     wsTickets?: WsTicketStore;
+    /** One-writer/many-observer terminal input coordinator. Injectable for deterministic multi-client tests. */
+    inputLeases?: InputLeaseCoordinator;
+    /** Team policy seam: direct local mode permits confirmed takeover; enterprise policy can deny it here. */
+    authorizeInputTakeover?: (principal: InputLeasePrincipal, sessionId: string) => boolean;
+    /** Optional policy seam for acquiring/writing input. Team RBAC is applied in addition when enabled. */
+    authorizeInputWrite?: (principal: InputLeasePrincipal, sessionId: string) => boolean;
+    /** Durable team membership and role assignments. start.ts supplies SQLite; tests may inject memory. */
+    teamStore?: TeamStore;
+    /** Durable organization policy. Disabled by default; enforced uniformly when explicitly enabled. */
+    policyStore?: PolicyStore;
+    /** Durable, explicitly scoped host-to-host API connections. Raw peer credentials never leave this store. */
+    peerStore?: PeerStore;
+    /** Isolated outbound peer transport; injectable so tests never contact developer or production hosts. */
+    peerFetch?: typeof globalThis.fetch;
+    /** Ephemeral, bounded presence heartbeats. */
+    presence?: PresenceCoordinator;
+    /** Advertises and enforces that this host has an outbound blind-relay transport configured. */
+    relayEnabled?: boolean;
+    /** Optional hosted/self-hosted bootstrap; absent means relay works for already-provisioned devices only. */
+    relayPairing?: RelayPairingBootstrap;
+    /** Late-bound host connector hook so device revocation closes relay channels immediately. */
+    onDeviceRevoked?: (deviceId: string) => void;
 }
 interface CreateServerResult {
     app: FastifyInstance;
     authGate: AuthGate;
+    /** Issue a five-minute, one-use pairing capability without exposing the host's master token. */
+    issuePairing(): PairingTicket;
+    /** Internal E2E-relay bridge. It authenticates relay-scoped devices through the exact normal route hooks. */
+    dispatchRelayRequest(token: string, request: RelayRpcRequest): Promise<RelayRpcResponse>;
+    /** Issues a relay-principal terminal ticket without exposing the bridge's process-local capability. */
+    issueRelayTerminalTicket(token: string): Promise<string>;
+    /** Process-local loopback headers for streamed relay HTTP. Never expose these outside this server process. */
+    relayLoopbackHeaders(token: string, headers?: Record<string, string>): Record<string, string>;
     /** Exposed so startServer can late-bind the MCP attach config (after listen() resolves the port) —
      *  this is what gives the terminal's claude send_image/send_file. */
     terminalManager: TerminalManager;
+    /** Exposed for relay/team composition and isolated ownership tests. */
+    inputLeases: InputLeaseCoordinator;
+    teamStore: TeamStore;
+    policyStore: PolicyStore;
+    peerStore: PeerStore;
+    presence: PresenceCoordinator;
     /** False when tmux/node-pty is unavailable → terminal sessions are disabled (startServer warns loudly). */
     terminalAvailable: boolean;
 }
@@ -2351,8 +4054,41 @@ declare function startServer(env?: NodeJS.ProcessEnv): Promise<CreateServerResul
     url: string;
     token?: string;
     tokenGenerated: boolean;
+    relayHost?: RelayHostConnector;
 }>;
 
+interface ProcessLifecycleTarget {
+    once(event: string, listener: (...args: unknown[]) => void): unknown;
+    off(event: string, listener: (...args: unknown[]) => void): unknown;
+    exit(code: number): never | void;
+}
+interface ProcessLifecycleOptions {
+    /** Close only on an intentional signal. Fatal errors exit immediately because process state is unknown. */
+    close: () => void | Promise<unknown>;
+    target?: ProcessLifecycleTarget;
+    log?: (message: string) => void;
+    shutdownTimeoutMs?: number;
+    setTimer?: typeof setTimeout;
+    clearTimer?: typeof clearTimeout;
+}
+interface ProcessLifecycleHandle {
+    dispose(): void;
+}
+/**
+ * Keep fatal diagnostics useful without copying bearer credentials, pairing links, or a maintainer's absolute
+ * home path into service logs. The summary deliberately uses Error.message rather than the full stack.
+ */
+declare function safeProcessErrorSummary(reason: unknown, home?: string): string;
+/**
+ * Own the process boundary for the always-on server.
+ *
+ * Intentional SIGTERM/SIGINT gets a bounded graceful close. An uncaught exception or unhandled rejection is
+ * different: Node cannot promise that application state remains valid, so the process exits non-zero immediately
+ * and lets launchd/systemd restart it. Keeping a possibly-corrupt process alive is how a listener can remain bound
+ * while every HTTP request stalls indefinitely.
+ */
+declare function installProcessLifecycle(options: ProcessLifecycleOptions): ProcessLifecycleHandle;
+
 /** Terminal mode needs BOTH a tmux binary and a loadable node-pty. Injectable for tests. */
 declare function detectTerminalSupport(deps?: {
     hasTmux?: () => boolean;
@@ -2435,9 +4171,23 @@ declare function enableService(record: ServiceRecord): {
 declare class ProviderOptionsError extends ProviderError {
     constructor(message: string);
 }
-declare function parseProviderOptions(provider: ProviderId, raw: unknown): ProviderSessionOptions;
+declare function parseProviderOptions(provider: ProviderId, raw: unknown, optionSchema?: Record<string, unknown>): ProviderSessionOptions;
 declare function parseLegacyClaudeArgs(args: readonly string[]): ClaudeSessionOptions;
 
+interface CreateInstalledAdapterProviderOptions {
+    extensions: ExtensionManager;
+    adapterId: string;
+    env?: NodeJS.ProcessEnv;
+}
+declare function createInstalledAdapterProvider(options: CreateInstalledAdapterProviderOptions): ProviderAdapterV1;
+
+type JsonObject = Record<string, unknown>;
+interface OpenApiBuildOptions {
+    serverVersion: string;
+    adapters: ReturnTypeOfDescriptors;
+}
+declare function buildOpenApiDocument(options: OpenApiBuildOptions): JsonObject;
+
 interface CreateClaudeProviderOptions {
     claudeBin: string;
     env?: NodeJS.ProcessEnv;
@@ -2445,7 +4195,7 @@ interface CreateClaudeProviderOptions {
     getAttach?: () => AttachSpawnOptions | undefined;
     probe?: () => Promise<ProviderAvailability>;
 }
-declare function createClaudeProvider(options: CreateClaudeProviderOptions): AgentProvider;
+declare function createClaudeProvider(options: CreateClaudeProviderOptions): ProviderAdapterV1;
 
 interface CreateCodexProviderOptions {
     codexBin: string;
@@ -2458,7 +4208,7 @@ interface CreateCodexProviderOptions {
 }
 type CodexAttachContext = Pick<AttachSpawnOptions, "baseUrl" | "token" | "mcpScriptPath">;
 declare function buildCodexArgs(context: ProviderProcessContext, attach?: CodexAttachContext): string[];
-declare function createCodexProvider(options: CreateCodexProviderOptions): AgentProvider;
+declare function createCodexProvider(options: CreateCodexProviderOptions): ProviderAdapterV1;
 
 declare const CODEX_EXECUTABLE_PROBE_TIMEOUT_MS = 5000;
 declare const OPENAI_CODE_SIGNING_TEAM_ID = "2DC432GLL2";
@@ -2512,4 +4262,4 @@ declare function codexClassifierVersionWarning(codexVersion: string | undefined)
 
 declare const SERVER_PACKAGE = "@roamcode.ai/server";
 
-export { API_PATH_DENYLIST, type AgentProvider, type AttachSpawnOptions, type AuthCheckResult, AuthGate, type AuthGateOptions, type Bar, CHECK_CACHE_MS, CLASSIFIER_TESTED_UP_TO, CLAUDE_LATEST_CACHE_MS, CLAUDE_VERSION_CACHE_MS, CLAUDE_VERSION_TIMEOUT_MS, CODEX_CLASSIFIER_TESTED_UP_TO, CODEX_EXECUTABLE_PROBE_TIMEOUT_MS, CODEX_OSC_MAX_CARRY, type CaptureOptions, type ChangelogEntry, type ClaudeAuthDeps, ClaudeAuthService, type ClaudeAuthStatus, type ClaudeAvailability, type ClaudeLatestDeps, ClaudeLatestService, type ClaudeMetadataRunner, ClaudeMetadataService, type ClaudeModelCatalogItem, type ClaudeSessionOptions, type ClaudeVersionProbe, type CodexAccount, CodexAppServerClient, type CodexAppServerClientOptions, type CodexDeviceLogin, type CodexExecutableDeps, type CodexExecutableProbe, type CodexExecutableResolution, type CodexInstallProvenance, CodexLatestService, type CodexLoginCompletion, type CodexLoginStatus, type CodexMetadataDiagnostics, type CodexMetadataRpc, CodexMetadataService, type CodexMetadataServiceOptions, type CodexModel, type CodexOscParser, type CodexProfileClientLifecycle, type CodexSessionOptions, type CodexSpawnLease, type CodexThreadInventoryEntry, type CodexThreadPersistence, CodexThreadResolver, type CodexThreadResolverOptions, type CodexUsage, type CodexVersionInfo, type CreateClaudeProviderOptions, type CreateCodexProfileClientLifecycleOptions, type CreateCodexProviderOptions, type CreatePushDispatcherDeps, type CreateServerDeps, type CreateServerResult, type CreateWebPushSendOptions, type DirEntry, type DirListing, type DirSearchResult, FETCH_TIMEOUT_MS, type FetchLatest, type FetchManifest, type FetchReleases, FsError, type FsErrorCode, FsService, type FsServiceOptions, type GitHubRelease, type HooksSettingsDocument, type IPty, type InstallServiceContext, type InstallServiceResult, type InstallationKind, type LaunchIntent, type ManagedInstallOptions, type ManagedInstallResult, type ManagedInstallStatus, type ManagedPaths, type McpConfigDocument, type ModelWeekBar, OPENAI_CODE_SIGNING_TEAM_ID, type OpenPushStoreOptions, type OpenSessionStoreOptions, type OriginCheckOptions, type PaneStatus, type ProcessSpec, type ProviderAvailability, ProviderError, type ProviderId, ProviderOptionsError, type ProviderProcessContext, ProviderRegistry, type ProviderRuntimeSignal, type ProviderRuntimeSignalParser, type ProviderSessionOptions, type PtySpawn, type PushDispatcher, type PushEvent, type PushEventKind, type PushPayload, type PushRecipient, type PushSendFn, type PushStore, type PushSubscriptionRecord, RUNNING_BUILD, RUNNING_VERSION, type RateLimitDecision, RateLimiter, type RateLimiterOptions, type RegisterStaticOptions, type ReleaseRecord, type RenderLaunchdOptions, type RenderSystemdOptions, type ResolveAccessTokenOptions, type ResolveCodexExecutableOptions, type ResolveCodexThreadOptions, type ResolveVapidKeysOptions, type RunClaudeVersion, type RunUsage, SEARCH_MAX_DEPTH, SEARCH_MAX_DIRS, SEARCH_MAX_RESULTS, SERVER_PACKAGE, SHELL_PATH_ALLOWLIST, type ServerConfig, type ServerRuntimeConfig, type ServiceRecord, type SessionDefaults, SessionDefaultsConflictError, type SessionFileDirection, type SessionFileKind, type SessionFileStorage, type SessionStore, type StoreMode, type StoredSession, type StoredSessionDefaults, type StoredSessionFile, type StoredStatus, TerminalManager, type TerminalManagerDeps, type TerminalMeta, TerminalProcess, type TerminalProcessOptions, type TerminalSub, USAGE_CACHE_MS, USAGE_TIMEOUT_MS, type UpdateAction, type UpdateState, type UpdateStatus, Updater, type UpdaterDeps, type UpdaterFs, type UsageInfo, UsageService, type UsageServiceDeps, type VapidKeys, type VersionInfo, WS_TICKET_TTL_MS, WsTicketStore, type WsTicketStoreOptions, assertConfigAllowsStart, buildCodexArgs, buildHooksSettingsDocument, buildMcpConfigDocument, buildPushPayload, buildServicePath, capturePane, classifierVersionWarning, classifyCodexPane, classifyPaneStatus, claudePreflightWarning, codexClassifierVersionWarning, compareVersions, computeBuildDrift, computeInstallDrift, createClaudeAuthService, createClaudeLatestService, createClaudeMetadataRunner, createClaudeProvider, createClaudeVersionProbe, createCodexOscParser, createCodexProfileClientLifecycle, createCodexProvider, createCodexThreadInventory, createCodexThreadPersistence, createPushDispatcher, createServer, createUpdater, createUsageRunner, createUsageService, createWebPushSend, defaultFetchManifest, defaultFetchReleases, defaultProbeCodexExecutable, defaultRunClaudeVersion, defaultUpdaterFs, detectTerminalSupport, enableService, ensureDataDir, extractBearerToken, extractLoginUrl, generateAccessToken, hasEncodedSep, hookAuthFileContent, hookAuthPathFor, hooksSettingsPathFor, installManagedRelease, installService, isCodexProfileClientLifecycle, isLoopbackAddress, isNewerMajorMinor, isOriginAllowed, isPublicForRequest, isPublicPath, isShellPath, isStableVersion, listTmuxSessions, loadConfig, loadServerConfig, looksLikeAssetRequest, managedPaths, mcpConfigPathFor, migrateServiceToLauncher, normalizeOrigin, normalizeProviderAvailability, normalizeRelease, normalizeSessionDefaults, openPushStore, openSessionStore, parseAllowedOrigins, parseAuthStatus, parseClaudeVersion, parseCodexOscNotifications, parseCodexVersion, parseLegacyClaudeArgs, parseNpmLatest, parseProviderOptions, parseReleaseNotes, parseUsage, pathForGate, persistAccessToken, providerPreflightWarning, readActiveVersion, readPreviousVersion, readServiceRecord, registerStatic, relativeWhen, renderLaunchdPlist, renderManagedLauncher, renderSystemdUnit, resetCodexThreadResolutionCoordinatorForTests, resolveAccessToken, resolveCodexExecutable, resolveDataDir, resolveInstallRoot, resolveVapidKeys, restartService, runClaudePreflight, runProviderPreflight, stableReleases, startServer, tmuxSessionName, writeManagedLauncher };
+export { ADAPTER_CONTRACT_VERSION, API_PATH_DENYLIST, type AdapterCapabilityName, AdapterManifestError, type AdapterManifestV1, type AdapterPackageManifestV1, type AdapterRuntimeV1, type AdapterStateAuthority, type AgentActivity, type AgentProvider, type AgentRecord, type AttachSpawnOptions, type AttentionItem, type AttentionKind, type AttentionState, type AuditActorType, type AuditRecord, type AuditResult, type AuthCheckResult, AuthGate, type AuthGateOptions, type AutomationAction, type AutomationDefinition, type AutomationRun, type AutomationTrigger, BLIND_RELAY_DEFAULT_MAX_BYTES_PER_MINUTE, BLIND_RELAY_DEFAULT_MAX_CONNECTIONS_PER_ROUTE, BLIND_RELAY_DEFAULT_MAX_FRAME_BYTES, BLIND_RELAY_DEFAULT_MAX_MESSAGES_PER_MINUTE, BLIND_RELAY_DEFAULT_MAX_QUEUE_BYTES, BLIND_RELAY_PROTOCOL_VERSION, type Bar, type BlindRelayMetrics, type BlindRelayServer, CHECK_CACHE_MS, CLASSIFIER_TESTED_UP_TO, CLAUDE_LATEST_CACHE_MS, CLAUDE_VERSION_CACHE_MS, CLAUDE_VERSION_TIMEOUT_MS, CODEX_CLASSIFIER_TESTED_UP_TO, CODEX_EXECUTABLE_PROBE_TIMEOUT_MS, CODEX_OSC_MAX_CARRY, CONTROL_IDEMPOTENCY_TTL_MS, type CaptureOptions, type ChangelogEntry, type ClaudeAuthDeps, ClaudeAuthService, type ClaudeAuthStatus, type ClaudeAvailability, type ClaudeLatestDeps, ClaudeLatestService, type ClaudeMetadataRunner, ClaudeMetadataService, type ClaudeModelCatalogItem, type ClaudeSessionOptions, type ClaudeVersionProbe, type CodexAccount, CodexAppServerClient, type CodexAppServerClientOptions, type CodexDeviceLogin, type CodexExecutableDeps, type CodexExecutableProbe, type CodexExecutableResolution, type CodexInstallProvenance, CodexLatestService, type CodexLoginCompletion, type CodexLoginStatus, type CodexMetadataDiagnostics, type CodexMetadataRpc, CodexMetadataService, type CodexMetadataServiceOptions, type CodexModel, type CodexOscParser, type CodexProfileClientLifecycle, type CodexSessionOptions, type CodexSpawnLease, type CodexThreadInventoryEntry, type CodexThreadPersistence, CodexThreadResolver, type CodexThreadResolverOptions, type CodexUsage, type CodexVersionInfo, CommandCenterRevisionConflictError, type CommandCenterStore, type CommandCenterStoreMode, type CommandEvent, type CommandLayoutEnvelope, type ControlStore, type ControlStoreMode, type CreateAutomationInput, type CreateBlindRelayOptions, type CreateClaudeProviderOptions, type CreateCodexProfileClientLifecycleOptions, type CreateCodexProviderOptions, type CreateInstalledAdapterProviderOptions, type CreatePeerInput, type CreatePluginRuntimeOptions, type CreatePushDispatcherDeps, type CreateRelayAccountInput, type CreateServerDeps, type CreateServerResult, type CreateWebPushSendOptions, type CreateWorktreeInput, type CreateWorktreeResult, type CreateWorktreeServiceOptions, type DeviceEnrollment, type DeviceInfo, DevicePairingError, type DeviceRelayIdentity, type DeviceScope, type DeviceStore, type DirEntry, type DirListing, type DirSearchResult, type DurableRelayIdentity, type EnterprisePolicy, type EnterprisePolicyAction, type EnterprisePolicyContext, type EnterprisePolicyDecision, EnterprisePolicyRevisionConflictError, type EnterprisePolicyUpdate, ExtensionError, type ExtensionKind, type ExtensionManager, type ExtensionManifestV1, type ExtensionPolicyMode, type ExtensionTrust, type ExtensionVersionRecord, FETCH_TIMEOUT_MS, type FetchLatest, type FetchManifest, type FetchReleases, FsError, type FsErrorCode, FsService, type FsServiceOptions, type GitHubRelease, type HooksSettingsDocument, type HostRecord, INPUT_LEASE_TTL_MS, type IPty, type IdempotencyRecord, type InputLease, type InputLeaseAcquireResult, type InputLeaseActorType, InputLeaseCoordinator, type InputLeaseCoordinatorOptions, type InputLeaseEvent, type InputLeasePrincipal, type InstallExtensionInput, type InstallServiceContext, type InstallServiceResult, type InstallationKind, type InstalledExtension, type LaunchIntent, type LoopbackRelayHttpOptions, type LoopbackRelayTerminalOptions, type ManagedInstallOptions, type ManagedInstallResult, type ManagedInstallStatus, type ManagedPaths, type MarketplaceEntry, type McpConfigDocument, type ModelWeekBar, OPENAI_CODE_SIGNING_TEAM_ID, type OpenApiBuildOptions, type OpenCommandCenterStoreOptions, type OpenControlStoreOptions, type OpenDeviceStoreOptions, type OpenExtensionManagerOptions, type OpenPeerStoreOptions, type OpenPolicyStoreOptions, type OpenPushStoreOptions, type OpenRelayAccountStoreOptions, type OpenRelayRouteStoreOptions, type OpenSessionStoreOptions, type OpenTeamStoreOptions, type OriginCheckOptions, PAIRING_TTL_MS, PRESENCE_HEARTBEAT_MS, PRESENCE_TTL_MS, type PairingTicket, type PaneStatus, type PeerAction, type PeerConnection, type PeerJsonResponse, type PeerRecord, PeerRequestError, PeerRevisionConflictError, type PeerStatus, type PeerStore, type PeerStoreMode, type PersistedRelayHostConfig, type PluginAuditEvent, type PluginManifestV1, type PluginPermission, type PluginRunInput, type PluginRunResult, type PluginRuntime, PluginRuntimeError, type PolicyStore, type PolicyStoreMode, PresenceCoordinator, type PresenceCoordinatorOptions, type PresenceEvent, type PresenceHeartbeatInput, type PresenceMode, type PresenceRecord, type PresenceTarget, type ProcessLifecycleHandle, type ProcessLifecycleOptions, type ProcessLifecycleTarget, type ProcessSpec, type ProviderAdapterV1, type ProviderAvailability, ProviderError, type ProviderId, ProviderOptionsError, type ProviderProcessContext, ProviderRegistry, type ProviderRuntimeSignal, type ProviderRuntimeSignalParser, type ProviderSessionOptions, type PtySpawn, type PublicRelayRouteRecord, type PushDispatcher, type PushEvent, type PushEventKind, type PushPayload, type PushRecipient, type PushSendFn, type PushStore, type PushSubscriptionRecord, RELAY_CHANNEL_MAX_AGE_MS, RELAY_CHANNEL_MAX_FRAMES, RELAY_HANDSHAKE_MAX_SKEW_MS, RELAY_MAX_PLAINTEXT_BYTES, RELAY_PROTOCOL_VERSION, RELAY_RPC_MAX_BODY_BYTES, RELAY_RPC_MAX_PATH_BYTES, RELAY_WIRE_MAX_ENVELOPE_BYTES, RELAY_WIRE_PROTOCOL_VERSION, RUNNING_BUILD, RUNNING_VERSION, type RateLimitDecision, RateLimiter, type RateLimiterOptions, type RegisterStaticOptions, type RelayAccountPlan, type RelayAccountRecord, RelayAccountRevisionConflictError, type RelayAccountStatus, type RelayAccountStore, type RelayAccountStoreMode, type RelayChannelOptions, RelayCipherState, RelayCryptoError, type RelayCryptoErrorCode, type RelayDeviceProvisioner, type RelayDeviceProvisionerOptions, type RelayDeviceRouteRecord, type RelayDirection, type RelayEncryptedFrame, type RelayEphemeralKeyPair, type RelayFrameKind, type RelayHandshakeHello, type RelayHostConfigInput, type RelayHostConnector, type RelayHostConnectorOptions, type RelayHostMetrics, type RelayHostRuntimeConfig, type RelayHostStatus, type RelayHttpBridge, type RelayHttpHandlers, type RelayHttpOpenRequest, type RelayHttpOpener, type RelayHttpResponseHead, type RelayIdentity, type RelayIdentityStoreOptions, type RelayPairingBootstrap, type RelayPairingPackage, type RelayRole, type RelayRouteRecord, type RelayRouteStore, type RelayRpcMethod, type RelayRpcRequest, type RelayRpcResponse, type RelayStoreMode, type RelayTerminalBridge, type RelayTerminalHandlers, type RelayTerminalOpenRequest, type RelayTerminalOpener, type RelayWireEnvelope, type ReleaseRecord, type RenderLaunchdOptions, type RenderSystemdOptions, type ResolveAccessTokenOptions, type ResolveCodexExecutableOptions, type ResolveCodexThreadOptions, type ResolveVapidKeysOptions, type ReturnTypeOfDescriptors, type RunClaudeVersion, type RunUsage, SEARCH_MAX_DEPTH, SEARCH_MAX_DIRS, SEARCH_MAX_RESULTS, SERVER_PACKAGE, SHELL_PATH_ALLOWLIST, type ServerConfig, type ServerRuntimeConfig, type ServiceRecord, type SessionDefaults, SessionDefaultsConflictError, type SessionFileDirection, type SessionFileKind, type SessionFileStorage, type SessionPlacement, type SessionStore, type StartedBlindRelay, type StoreMode, type StoredExternalSession, type StoredSession, type StoredSessionDefaults, type StoredSessionFile, type StoredStatus, type TeamAuthorizationDecision, type TeamAuthorizationResource, type TeamMember, type TeamMemberKind, type TeamMemberStatus, type TeamPermission, type TeamPrincipalBinding, type TeamPrincipalType, type TeamRecord, TeamRevisionConflictError, type TeamRole, type TeamRoleBinding, type TeamScopeType, type TeamStore, type TeamStoreMode, TerminalManager, type TerminalManagerDeps, type TerminalMeta, TerminalProcess, type TerminalProcessOptions, type TerminalSub, USAGE_CACHE_MS, USAGE_TIMEOUT_MS, type UpdateAction, type UpdateAutomationInput, type UpdatePeerInput, type UpdatePolicyMode, type UpdateRelayAccountInput, type UpdateState, type UpdateStatus, Updater, type UpdaterDeps, type UpdaterFs, type UsageInfo, UsageService, type UsageServiceDeps, type VapidKeys, type VerifiedPeerIdentity, type VersionInfo, WS_TICKET_TTL_MS, type WorkspaceKind, type WorkspaceRecord, WorktreeError, type WorktreeErrorCode, type WorktreeRecord, type WorktreeService, type WsTicketContext, WsTicketStore, type WsTicketStoreOptions, adapterCapabilityNames, assertConfigAllowsStart, buildCodexArgs, buildHooksSettingsDocument, buildMcpConfigDocument, buildOpenApiDocument, buildPushPayload, buildRelayPairingUrl, buildServicePath, capturePane, classifierVersionWarning, classifyCodexPane, classifyPaneStatus, claudePreflightWarning, codexClassifierVersionWarning, compareVersions, computeBuildDrift, computeInstallDrift, createBlindRelayServer, createClaudeAuthService, createClaudeLatestService, createClaudeMetadataRunner, createClaudeProvider, createClaudeVersionProbe, createCodexOscParser, createCodexProfileClientLifecycle, createCodexProvider, createCodexThreadInventory, createCodexThreadPersistence, createInstalledAdapterProvider, createLoopbackRelayHttpOpener, createLoopbackRelayTerminalOpener, createPluginRuntime, createPushDispatcher, createRelayDeviceProvisioner, createRelayHandshakeHello, createRelayHostConnector, createServer, createUpdater, createUsageRunner, createUsageService, createWebPushSend, createWorktreeService, currentAgentIdForSession, decodeRelayWireEnvelope, defaultFetchManifest, defaultFetchReleases, defaultProbeCodexExecutable, defaultRunClaudeVersion, defaultUpdaterFs, defineAdapterManifest, detectTerminalSupport, enableService, encodeRelayWireEnvelope, ensureDataDir, establishRelayChannel, evaluateEnterprisePolicy, extractBearerToken, extractLoginUrl, generateAccessToken, generateRelayAccountCredential, generateRelayCredential, generateRelayEphemeralKeyPair, generateRelayIdentity, hasEncodedSep, hkdfSha256, hookAuthFileContent, hookAuthPathFor, hooksSettingsPathFor, inspectExtensionPackage, installManagedRelease, installProcessLifecycle, installService, isCodexProfileClientLifecycle, isLoopbackAddress, isNewerMajorMinor, isOriginAllowed, isPublicForRequest, isPublicPath, isRelayDirectExecution, isShellPath, isStableVersion, isTeamRole, isTeamScopeType, listTmuxSessions, loadConfig, loadOrCreateRelayIdentity, loadServerConfig, looksLikeAssetRequest, managedPaths, mcpConfigPathFor, migrateServiceToLauncher, normalizeAutomationAction, normalizeAutomationInput, normalizeAutomationTrigger, normalizeCommandCenterLabel, normalizeDeviceName, normalizeDeviceScopes, normalizeOrigin, normalizePeerBaseUrl, normalizeProviderAvailability, normalizeRelayAppUrl, normalizeRelease, normalizeSessionDefaults, openCommandCenterStore, openControlStore, openDeviceStore, openExtensionManager, openPeerStore, openPolicyStore, openPushStore, openRelayAccountStore, openRelayRouteStore, openSessionStore, openTeamStore, parseAllowedOrigins, parseAuthStatus, parseClaudeVersion, parseCodexOscNotifications, parseCodexVersion, parseLegacyClaudeArgs, parseMarketplaceIndex, parseNpmLatest, parseProviderOptions, parseRelayRpcRequest, parseReleaseNotes, parseUsage, pathForGate, persistAccessToken, privacySafeAuditMetadata, providerPreflightWarning, publicAdapterDescriptor, readActiveVersion, readPreviousVersion, readRelayHostConfig, readServiceRecord, registerStatic, relativeWhen, relayAccountCredentialHash, relayAccountCredentialLookup, relayConnectUrl, relayCredentialHash, relayHostConfigPath, relayIdentityFingerprint, relayRpcResponse, removeRelayHostConfig, renderLaunchdPlist, renderManagedLauncher, renderSystemdUnit, requestPeerJson, resetCodexThreadResolutionCoordinatorForTests, resolveAccessToken, resolveCodexExecutable, resolveDataDir, resolveInstallRoot, resolveRelayHostConfig, resolveVapidKeys, restartService, runClaudePreflight, runProviderPreflight, safeProcessErrorSummary, searchMarketplace, stableReleases, startBlindRelay, startServer, teamRolePermissions, tmuxSessionName, validateAdapterManifest, validateAdapterOptionSchema, validateRelayIdentity, verifyPeerConnection, verifyRelayHandshakeHello, writeManagedLauncher, writeRelayHostConfig };