@nyte-ai/schema 0.0.0-stage → 0.0.18

package/dist/src/wire/operations/host.d.ts

@@ -0,0 +1,1011 @@
+export declare const HOST_OPERATIONS: {
+    readonly "connection.watch": {
+        readonly kind: "watch";
+        readonly input: import("../../schema.ts").Schema<object>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly link: {
+                readonly kind: "connected";
+            } | {
+                readonly kind: "reconnecting";
+                readonly since: number;
+                readonly attempts: number;
+            } | {
+                readonly kind: "closed";
+                readonly reason: "client" | "revoked" | "host-gone";
+            };
+            readonly name: string;
+            readonly principal: import("../../ids.ts").Id<"principal">;
+            readonly id: import("../../ids.ts").Id<"host">;
+            readonly settings: readonly {
+                readonly value: import("../../json.ts").Json;
+                readonly id: string;
+                readonly label: string;
+                readonly owner: string;
+                readonly from: "session" | "host" | "default";
+                readonly scope: "session" | "host";
+                readonly schema: {
+                    readonly [x: string]: import("../../json.ts").Json;
+                };
+                readonly choices: readonly {
+                    readonly badge?: string | undefined;
+                    readonly value: import("../../json.ts").Json;
+                    readonly label: string;
+                }[] | null;
+            }[];
+            readonly authority: readonly ("participant" | "owner" | "maintenance")[];
+            readonly plugins: readonly {
+                readonly issues: readonly {
+                    readonly source?: {
+                        readonly file?: string | undefined;
+                        readonly line?: number | undefined;
+                        readonly plugin: string;
+                    } | undefined;
+                    readonly message: string;
+                    readonly severity: "error" | "warning";
+                    readonly path: readonly (string | number)[];
+                }[];
+                readonly id: string;
+                readonly path: string | null;
+                readonly source: "user" | "builtin" | "project" | "inline";
+            }[];
+            readonly platform: string;
+            readonly version: string;
+            readonly catalog: import("../../ids.ts").Id<"catalog-generation">;
+            readonly defaultWorkspace: import("../../ids.ts").Id<"workspace"> | null;
+        }>;
+        readonly authority: "participant";
+        readonly scope: "host";
+    };
+    readonly "connection.blob": {
+        readonly kind: "stream";
+        readonly input: import("../../schema.ts").Schema<{
+            id: import("../../ids.ts").Id<"blob">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<Uint8Array<ArrayBufferLike>>;
+        readonly authority: "participant";
+        readonly scope: "host";
+    };
+    readonly "models.list": {
+        readonly kind: "query";
+        readonly input: import("../../schema.ts").Schema<object>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly generation: import("../../ids.ts").Id<"catalog-generation">;
+            readonly default: {
+                readonly id: string;
+                readonly provider: string;
+            } | null;
+            readonly providers: readonly {
+                readonly name: string;
+                readonly id: string;
+                readonly limits: readonly {
+                    readonly label: string;
+                    readonly used: number;
+                    readonly limit: number;
+                    readonly resetsAt: number | null;
+                }[];
+                readonly credential: "failed" | "unknown" | "missing" | "configured" | "verified";
+                readonly methods: readonly ({
+                    readonly kind: "oauth";
+                } | {
+                    readonly kind: "key";
+                })[];
+                readonly models: readonly {
+                    readonly name: string;
+                    readonly ref: {
+                        readonly id: string;
+                        readonly provider: string;
+                    };
+                    readonly input: readonly ("text" | "image")[];
+                    readonly reasoning: boolean;
+                    readonly cost: {
+                        readonly output: number;
+                        readonly input: number;
+                        readonly cacheRead: number;
+                        readonly cacheWrite: number;
+                    };
+                    readonly thinking: readonly ("off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max")[];
+                    readonly defaultThinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                    readonly fast: {
+                        readonly id: string;
+                        readonly provider: string;
+                    } | null;
+                    readonly contextWindow: number;
+                    readonly compactAt: number;
+                    readonly maxOutput: number;
+                    readonly capabilities: {
+                        readonly steer: boolean;
+                    };
+                }[];
+            }[];
+        }>;
+        readonly authority: "participant";
+        readonly scope: "host";
+    };
+    readonly "models.accounts": {
+        readonly kind: "query";
+        readonly input: import("../../schema.ts").Schema<{
+            provider?: string | undefined;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            id: string;
+            provider: string;
+            label: string;
+            method: {
+                kind: "oauth";
+            } | {
+                kind: "key";
+            };
+            active: boolean;
+        }[]>;
+        readonly authority: "owner";
+        readonly scope: "host";
+    };
+    readonly "models.selectAccount": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            provider: string;
+            account: string;
+        }>;
+        readonly output: import("../../schema.ts").Schema<null>;
+        readonly authority: "owner";
+        readonly scope: "host";
+    };
+    readonly "models.usage": {
+        readonly kind: "query";
+        readonly input: import("../../schema.ts").Schema<object>;
+        readonly output: import("../../schema.ts").Schema<{
+            name: string;
+            provider: string;
+            account: {
+                id: string;
+                provider: string;
+                label: string;
+                method: {
+                    kind: "oauth";
+                } | {
+                    kind: "key";
+                };
+                active: boolean;
+            } | null;
+            state: {
+                error: string | null;
+                kind: "ready";
+                stale: boolean;
+                limits: {
+                    label: string;
+                    used: number;
+                    limit: number;
+                    resetsAt: number | null;
+                }[];
+                observedAt: number;
+            } | {
+                message: string;
+                kind: "unavailable";
+                reason: "unsupported" | "unconfigured" | "failed";
+            };
+        }[]>;
+        readonly authority: "owner";
+        readonly scope: "host";
+    };
+    readonly "models.refresh": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            provider?: string | undefined;
+        }>;
+        readonly output: import("../../schema.ts").Schema<null>;
+        readonly authority: "owner";
+        readonly scope: "host";
+    };
+    readonly "models.setDefault": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            ref: {
+                id: string;
+                provider: string;
+            };
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            kind: "set";
+        } | {
+            kind: "unknown-model";
+        }>;
+        readonly authority: "owner";
+        readonly scope: "host";
+    };
+    readonly "models.verify": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            provider: string;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            kind: "verified";
+        } | {
+            kind: "unverified";
+        } | {
+            kind: "failed";
+            reason: string;
+        }>;
+        readonly authority: "owner";
+        readonly scope: "host";
+    };
+    readonly "models.login": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            label?: string | undefined;
+            browser?: "host" | "elsewhere" | undefined;
+            provider: string;
+            method: {
+                kind: "oauth";
+            } | {
+                kind: "key";
+            };
+        }>;
+        readonly output: import("../../schema.ts").Schema<null>;
+        readonly authority: "owner";
+        readonly scope: "host";
+    };
+    readonly "models.logout": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            provider: string;
+        }>;
+        readonly output: import("../../schema.ts").Schema<null>;
+        readonly authority: "owner";
+        readonly scope: "host";
+    };
+    readonly "login.steps": {
+        readonly kind: "stream";
+        readonly input: import("../../schema.ts").Schema<{
+            provider: string;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            code?: string | undefined;
+            url: string;
+            kind: "open";
+        } | {
+            message: string;
+            kind: "paste";
+            secret: boolean;
+        } | {
+            message: string;
+            kind: "choose";
+            options: {
+                id: string;
+                label: string;
+            }[];
+        } | {
+            kind: "waiting";
+        } | {
+            kind: "done";
+        } | {
+            kind: "failed";
+            reason: string;
+        }>;
+        readonly authority: "owner";
+        readonly scope: "host";
+    };
+    readonly "login.answer": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            provider: string;
+            code: string;
+        }>;
+        readonly output: import("../../schema.ts").Schema<null>;
+        readonly authority: "owner";
+        readonly scope: "host";
+    };
+    readonly "settings.apply": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            value: import("../../json.ts").Json;
+            id: string;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly kind: "applied";
+        } | {
+            readonly issues: readonly {
+                readonly source?: {
+                    readonly file?: string | undefined;
+                    readonly line?: number | undefined;
+                    readonly plugin: string;
+                } | undefined;
+                readonly message: string;
+                readonly severity: "error" | "warning";
+                readonly path: readonly (string | number)[];
+            }[];
+            readonly kind: "invalid";
+        } | {
+            readonly kind: "unknown";
+        }>;
+        readonly authority: "owner";
+        readonly scope: "host";
+    };
+    readonly "workspaces.list": {
+        readonly kind: "query";
+        readonly input: import("../../schema.ts").Schema<object>;
+        readonly output: import("../../schema.ts").Schema<{
+            id: import("../../ids.ts").Id<"workspace">;
+            sessions: number;
+            identity: import("../../ids.ts").Id<"environment-identity">;
+            target: {
+                kind: "local";
+                path: string;
+            } | {
+                kind: string;
+                locator: import("../../json.ts").Json;
+            };
+            availability: {
+                kind: "available";
+            } | {
+                kind: "unavailable";
+                reason: "unreachable" | "unsupported";
+            };
+            projectSources: string[];
+            projectResources: boolean | null;
+            trusted: boolean | null;
+            addedBy: import("../../ids.ts").Id<"principal">;
+            writers: import("../../ids.ts").Id<"run">[];
+            isolation: {
+                session: import("../../ids.ts").Id<"session">;
+                kind: "worktree";
+                source: import("../../ids.ts").Id<"workspace">;
+                branch: string;
+                base: string;
+            } | null;
+        }[]>;
+        readonly authority: "participant";
+        readonly scope: "host";
+    };
+    readonly "workspaces.inspect": {
+        readonly kind: "query";
+        readonly input: import("../../schema.ts").Schema<{
+            target: {
+                kind: "local";
+                path: string;
+            } | {
+                kind: string;
+                locator: import("../../json.ts").Json;
+            };
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly identity: import("../../ids.ts").Id<"environment-identity">;
+            readonly target: {
+                readonly kind: "local";
+                readonly path: string;
+            } | {
+                readonly kind: string;
+                readonly locator: import("../../json.ts").Json;
+            };
+            readonly availability: {
+                readonly kind: "available";
+            } | {
+                readonly kind: "unavailable";
+                readonly reason: "unreachable" | "unsupported";
+            };
+            readonly projectSources: readonly string[];
+            readonly registered: import("../../ids.ts").Id<"workspace"> | null;
+        }>;
+        readonly authority: "owner";
+        readonly scope: "host";
+    };
+    readonly "workspaces.add": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            options?: {
+                expect?: {
+                    identity: import("../../ids.ts").Id<"environment-identity">;
+                } | undefined;
+                projectResources?: boolean | undefined;
+            } | undefined;
+            target: {
+                kind: "local";
+                path: string;
+            } | {
+                kind: string;
+                locator: import("../../json.ts").Json;
+            };
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly workspace: import("../../ids.ts").Id<"workspace">;
+            readonly kind: "added";
+        } | {
+            readonly workspace: import("../../ids.ts").Id<"workspace">;
+            readonly kind: "exists";
+        } | {
+            readonly kind: "stale";
+            readonly identity: import("../../ids.ts").Id<"environment-identity">;
+        } | {
+            readonly kind: "unavailable";
+            readonly reason: "unreachable" | "unsupported";
+        }>;
+        readonly authority: "owner";
+        readonly scope: "host";
+    };
+    readonly "workspaces.forget": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            id: import("../../ids.ts").Id<"workspace">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly kind: "forgotten";
+        } | {
+            readonly kind: "busy";
+            readonly sessions: readonly import("../../ids.ts").Id<"session">[];
+        } | {
+            readonly kind: "missing";
+        }>;
+        readonly authority: "owner";
+        readonly scope: "host";
+    };
+    readonly "sessions.watch": {
+        readonly kind: "watch";
+        readonly input: import("../../schema.ts").Schema<{
+            limit?: number | undefined;
+            parents?: {
+                kind: "all";
+            } | {
+                kind: "roots";
+            } | {
+                session: import("../../ids.ts").Id<"session">;
+                kind: "children";
+            } | undefined;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            name: string | null;
+            call: import("../../ids.ts").Id<"call"> | null;
+            workspace: import("../../ids.ts").Id<"workspace">;
+            id: import("../../ids.ts").Id<"session">;
+            parent: import("../../ids.ts").Id<"session"> | null;
+            heads: {
+                name: import("../../ids.ts").Id<"head">;
+                tip: {
+                    kind: "start";
+                } | {
+                    id: import("../../ids.ts").Id<"commit">;
+                    kind: "commit";
+                };
+                stack: {
+                    stale: boolean;
+                    parent: import("../../ids.ts").Id<"head">;
+                    base: {
+                        kind: "start";
+                    } | {
+                        id: import("../../ids.ts").Id<"commit">;
+                        kind: "commit";
+                    };
+                } | null;
+                execution: {
+                    kind: "idle";
+                    lastRun: {
+                        id: import("../../ids.ts").Id<"run">;
+                        end: {
+                            kind: "completed";
+                            usage: {
+                                output: number;
+                                input: number;
+                                cacheRead: number;
+                                cacheWrite: number;
+                                reasoning: number | null;
+                                total: number;
+                                cost: {
+                                    output: number;
+                                    input: number;
+                                    cacheRead: number;
+                                    cacheWrite: number;
+                                    total: number;
+                                };
+                            };
+                        } | {
+                            kind: "stopped";
+                        } | {
+                            kind: "failed";
+                            failure: {
+                                retryAfterMs?: number | undefined;
+                                message: string;
+                                class: "provider" | "rate_limit" | "auth" | "quota" | "context_window" | "overloaded" | "network" | "aborted" | "runner";
+                            };
+                        };
+                        endedAt: number;
+                    } | null;
+                } | {
+                    run: {
+                        head: import("../../ids.ts").Id<"head">;
+                        id: import("../../ids.ts").Id<"run">;
+                        configuration: {
+                            kind: "exact";
+                            thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                            model: {
+                                id: string;
+                                provider: string;
+                            };
+                            agent: string | null;
+                            settings: Record<string, import("../../json.ts").Json>;
+                            settingsVersion: string;
+                        };
+                        startedAt: number;
+                        attempt: number;
+                        origin: {
+                            message: import("../../ids.ts").Id<"message">;
+                            kind: "input";
+                        } | {
+                            kind: "continuation";
+                            from: "job" | "child" | "wake";
+                        };
+                    };
+                    kind: "live";
+                    phase: "responding" | "executing";
+                    stopping: boolean;
+                } | {
+                    run: {
+                        head: import("../../ids.ts").Id<"head">;
+                        id: import("../../ids.ts").Id<"run">;
+                        configuration: {
+                            kind: "exact";
+                            thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                            model: {
+                                id: string;
+                                provider: string;
+                            };
+                            agent: string | null;
+                            settings: Record<string, import("../../json.ts").Json>;
+                            settingsVersion: string;
+                        };
+                        startedAt: number;
+                        attempt: number;
+                        origin: {
+                            message: import("../../ids.ts").Id<"message">;
+                            kind: "input";
+                        } | {
+                            kind: "continuation";
+                            from: "job" | "child" | "wake";
+                        };
+                    };
+                    kind: "waiting";
+                    on: {
+                        deadline?: number | undefined;
+                        session: import("../../ids.ts").Id<"session">;
+                        run: import("../../ids.ts").Id<"run">;
+                        kind: "run";
+                    } | {
+                        deadline?: number | undefined;
+                        job: import("../../ids.ts").Id<"job">;
+                        kind: "job";
+                    } | {
+                        deadline?: number | undefined;
+                        part: import("../../ids.ts").Id<"part">;
+                        kind: "part";
+                    } | {
+                        deadline?: number | undefined;
+                        kind: "timer";
+                        until: number;
+                    };
+                } | {
+                    run: {
+                        head: import("../../ids.ts").Id<"head">;
+                        id: import("../../ids.ts").Id<"run">;
+                        configuration: {
+                            kind: "exact";
+                            thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                            model: {
+                                id: string;
+                                provider: string;
+                            };
+                            agent: string | null;
+                            settings: Record<string, import("../../json.ts").Json>;
+                            settingsVersion: string;
+                        };
+                        startedAt: number;
+                        attempt: number;
+                        origin: {
+                            message: import("../../ids.ts").Id<"message">;
+                            kind: "input";
+                        } | {
+                            kind: "continuation";
+                            from: "job" | "child" | "wake";
+                        };
+                    };
+                    kind: "retrying";
+                    reason: string;
+                    until: number;
+                };
+                unread: boolean;
+            }[];
+            pinned: boolean;
+            archived: boolean;
+            activation: {
+                kind: "active";
+            } | {
+                kind: "inactive";
+            } | {
+                workspace: import("../../ids.ts").Id<"workspace">;
+                kind: "unavailable";
+                reason: "unreachable" | "unsupported";
+            } | {
+                message: string;
+                kind: "failed";
+            };
+            createdAt: number;
+            lastActivityAt: number;
+        }[]>;
+        readonly authority: "participant";
+        readonly scope: "host";
+    };
+    readonly "sessions.start": {
+        readonly kind: "receipt";
+        readonly recovery: "replay";
+        readonly input: import("../../schema.ts").Schema<{
+            name?: string | undefined;
+            workspace?: import("../../ids.ts").Id<"workspace"> | undefined;
+            configuration?: {
+                kind: "exact";
+                thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                model: {
+                    id: string;
+                    provider: string;
+                };
+                agent: string | null;
+                settings: Record<string, import("../../json.ts").Json>;
+                settingsVersion: string;
+            } | {
+                thinking?: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max" | null | undefined;
+                model?: {
+                    id: string;
+                    provider: string;
+                } | undefined;
+                agent?: string | null | undefined;
+                settings?: Record<string, import("../../json.ts").Json> | undefined;
+            } | undefined;
+            parent?: import("../../ids.ts").Id<"session"> | undefined;
+            isolation?: "worktree" | undefined;
+            prompt?: {
+                order?: number | undefined;
+                text: string;
+                kind: "layer";
+            } | {
+                text: string;
+                kind: "replace";
+            } | undefined;
+            id: import("../../ids.ts").Id<"session">;
+            content: string | ({
+                text: string;
+                kind: "text";
+            } | {
+                name: string;
+                blob: import("../../ids.ts").Id<"blob">;
+                kind: "file";
+                mime: string;
+            } | {
+                blob?: import("../../ids.ts").Id<"blob"> | undefined;
+                kind: "reference";
+                path: string;
+            } | {
+                name: string;
+                kind: "skill";
+                location: string;
+            } | {
+                text: string;
+                kind: "excerpt";
+                source: {
+                    kind: "diff";
+                    path: string;
+                    side: "old" | "new";
+                    start: number;
+                    end: number;
+                } | {
+                    command?: string | undefined;
+                    kind: "terminal";
+                } | {
+                    url: string;
+                    kind: "browser";
+                    selector: string;
+                };
+            })[];
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            session: import("../../ids.ts").Id<"session">;
+            message: import("../../ids.ts").Id<"message">;
+            receipt: import("../../ids.ts").Id<"receipt">;
+        }>;
+        readonly authority: "participant";
+        readonly scope: "host";
+    };
+    readonly "sessions.list": {
+        readonly kind: "query";
+        readonly input: import("../../schema.ts").Schema<{
+            cursor?: import("../../ids.ts").Id<"cursor"> | undefined;
+            limit?: number | undefined;
+            parents?: {
+                kind: "all";
+            } | {
+                kind: "roots";
+            } | {
+                session: import("../../ids.ts").Id<"session">;
+                kind: "children";
+            } | undefined;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            items: {
+                name: string | null;
+                call: import("../../ids.ts").Id<"call"> | null;
+                workspace: import("../../ids.ts").Id<"workspace">;
+                id: import("../../ids.ts").Id<"session">;
+                parent: import("../../ids.ts").Id<"session"> | null;
+                heads: {
+                    name: import("../../ids.ts").Id<"head">;
+                    tip: {
+                        kind: "start";
+                    } | {
+                        id: import("../../ids.ts").Id<"commit">;
+                        kind: "commit";
+                    };
+                    stack: {
+                        stale: boolean;
+                        parent: import("../../ids.ts").Id<"head">;
+                        base: {
+                            kind: "start";
+                        } | {
+                            id: import("../../ids.ts").Id<"commit">;
+                            kind: "commit";
+                        };
+                    } | null;
+                    execution: {
+                        kind: "idle";
+                        lastRun: {
+                            id: import("../../ids.ts").Id<"run">;
+                            end: {
+                                kind: "completed";
+                                usage: {
+                                    output: number;
+                                    input: number;
+                                    cacheRead: number;
+                                    cacheWrite: number;
+                                    reasoning: number | null;
+                                    total: number;
+                                    cost: {
+                                        output: number;
+                                        input: number;
+                                        cacheRead: number;
+                                        cacheWrite: number;
+                                        total: number;
+                                    };
+                                };
+                            } | {
+                                kind: "stopped";
+                            } | {
+                                kind: "failed";
+                                failure: {
+                                    retryAfterMs?: number | undefined;
+                                    message: string;
+                                    class: "provider" | "rate_limit" | "auth" | "quota" | "context_window" | "overloaded" | "network" | "aborted" | "runner";
+                                };
+                            };
+                            endedAt: number;
+                        } | null;
+                    } | {
+                        run: {
+                            head: import("../../ids.ts").Id<"head">;
+                            id: import("../../ids.ts").Id<"run">;
+                            configuration: {
+                                kind: "exact";
+                                thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                                model: {
+                                    id: string;
+                                    provider: string;
+                                };
+                                agent: string | null;
+                                settings: Record<string, import("../../json.ts").Json>;
+                                settingsVersion: string;
+                            };
+                            startedAt: number;
+                            attempt: number;
+                            origin: {
+                                message: import("../../ids.ts").Id<"message">;
+                                kind: "input";
+                            } | {
+                                kind: "continuation";
+                                from: "job" | "child" | "wake";
+                            };
+                        };
+                        kind: "live";
+                        phase: "responding" | "executing";
+                        stopping: boolean;
+                    } | {
+                        run: {
+                            head: import("../../ids.ts").Id<"head">;
+                            id: import("../../ids.ts").Id<"run">;
+                            configuration: {
+                                kind: "exact";
+                                thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                                model: {
+                                    id: string;
+                                    provider: string;
+                                };
+                                agent: string | null;
+                                settings: Record<string, import("../../json.ts").Json>;
+                                settingsVersion: string;
+                            };
+                            startedAt: number;
+                            attempt: number;
+                            origin: {
+                                message: import("../../ids.ts").Id<"message">;
+                                kind: "input";
+                            } | {
+                                kind: "continuation";
+                                from: "job" | "child" | "wake";
+                            };
+                        };
+                        kind: "waiting";
+                        on: {
+                            deadline?: number | undefined;
+                            session: import("../../ids.ts").Id<"session">;
+                            run: import("../../ids.ts").Id<"run">;
+                            kind: "run";
+                        } | {
+                            deadline?: number | undefined;
+                            job: import("../../ids.ts").Id<"job">;
+                            kind: "job";
+                        } | {
+                            deadline?: number | undefined;
+                            part: import("../../ids.ts").Id<"part">;
+                            kind: "part";
+                        } | {
+                            deadline?: number | undefined;
+                            kind: "timer";
+                            until: number;
+                        };
+                    } | {
+                        run: {
+                            head: import("../../ids.ts").Id<"head">;
+                            id: import("../../ids.ts").Id<"run">;
+                            configuration: {
+                                kind: "exact";
+                                thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                                model: {
+                                    id: string;
+                                    provider: string;
+                                };
+                                agent: string | null;
+                                settings: Record<string, import("../../json.ts").Json>;
+                                settingsVersion: string;
+                            };
+                            startedAt: number;
+                            attempt: number;
+                            origin: {
+                                message: import("../../ids.ts").Id<"message">;
+                                kind: "input";
+                            } | {
+                                kind: "continuation";
+                                from: "job" | "child" | "wake";
+                            };
+                        };
+                        kind: "retrying";
+                        reason: string;
+                        until: number;
+                    };
+                    unread: boolean;
+                }[];
+                pinned: boolean;
+                archived: boolean;
+                activation: {
+                    kind: "active";
+                } | {
+                    kind: "inactive";
+                } | {
+                    workspace: import("../../ids.ts").Id<"workspace">;
+                    kind: "unavailable";
+                    reason: "unreachable" | "unsupported";
+                } | {
+                    message: string;
+                    kind: "failed";
+                };
+                createdAt: number;
+                lastActivityAt: number;
+            }[];
+            next: import("../../ids.ts").Id<"cursor"> | null;
+        }>;
+        readonly authority: "participant";
+        readonly scope: "host";
+    };
+};
+export declare const MAINTENANCE_OPERATIONS: {
+    readonly "plugins.replace": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            scope?: {
+                session: import("../../ids.ts").Id<"session">;
+            } | undefined;
+            plugins: {
+                path: string;
+            }[];
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly generation: import("../../ids.ts").Id<"catalog-generation">;
+            readonly plugins: readonly {
+                readonly issues: readonly {
+                    readonly source?: {
+                        readonly file?: string | undefined;
+                        readonly line?: number | undefined;
+                        readonly plugin: string;
+                    } | undefined;
+                    readonly message: string;
+                    readonly severity: "error" | "warning";
+                    readonly path: readonly (string | number)[];
+                }[];
+                readonly id: string;
+                readonly kind: "activated" | "rejected" | "kept-previous";
+            }[];
+        }>;
+        readonly authority: "maintenance";
+        readonly scope: "host";
+    };
+    readonly "plugins.check": {
+        readonly kind: "query";
+        readonly input: import("../../schema.ts").Schema<{
+            plugins: {
+                path: string;
+            }[];
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly plugins: readonly {
+                readonly issues: readonly {
+                    readonly source?: {
+                        readonly file?: string | undefined;
+                        readonly line?: number | undefined;
+                        readonly plugin: string;
+                    } | undefined;
+                    readonly message: string;
+                    readonly severity: "error" | "warning";
+                    readonly path: readonly (string | number)[];
+                }[];
+                readonly id: string;
+                readonly kind: "activated" | "rejected" | "kept-previous";
+            }[];
+            readonly collisions: readonly {
+                readonly source?: {
+                    readonly file?: string | undefined;
+                    readonly line?: number | undefined;
+                    readonly plugin: string;
+                } | undefined;
+                readonly message: string;
+                readonly severity: "error" | "warning";
+                readonly path: readonly (string | number)[];
+            }[];
+        }>;
+        readonly authority: "maintenance";
+        readonly scope: "host";
+    };
+    readonly "principals.list": {
+        readonly kind: "query";
+        readonly input: import("../../schema.ts").Schema<object>;
+        readonly output: import("../../schema.ts").Schema<{
+            id: import("../../ids.ts").Id<"principal">;
+            label: string;
+            authority: ("participant" | "owner" | "maintenance")[];
+            pairedAt: number;
+        }[]>;
+        readonly authority: "maintenance";
+        readonly scope: "host";
+    };
+    readonly "principals.pair": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            label?: string | undefined;
+            authority: ("participant" | "owner" | "maintenance")[];
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            code: string;
+            expiresAt: number;
+        }>;
+        readonly authority: "maintenance";
+        readonly scope: "host";
+    };
+    readonly "principals.revoke": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            id: import("../../ids.ts").Id<"principal">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<null>;
+        readonly authority: "maintenance";
+        readonly scope: "host";
+    };
+};