@nyte-ai/schema 0.0.0-stage → 0.0.19

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

@@ -0,0 +1,842 @@
+export declare const WORKSPACE_OPERATIONS: {
+    readonly "workspace.info": {
+        readonly kind: "query";
+        readonly input: import("../../schema.ts").Schema<{
+            workspace: import("../../ids.ts").Id<"workspace">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly id: import("../../ids.ts").Id<"workspace">;
+            readonly sessions: number;
+            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 projectResources: boolean | null;
+            readonly trusted: boolean | null;
+            readonly addedBy: import("../../ids.ts").Id<"principal">;
+            readonly writers: readonly import("../../ids.ts").Id<"run">[];
+            readonly isolation: {
+                readonly session: import("../../ids.ts").Id<"session">;
+                readonly kind: "worktree";
+                readonly source: import("../../ids.ts").Id<"workspace">;
+                readonly branch: string;
+                readonly base: string;
+            } | null;
+        }>;
+        readonly authority: "participant";
+        readonly scope: "workspace";
+    };
+    readonly "workspace.watch": {
+        readonly kind: "watch";
+        readonly input: import("../../schema.ts").Schema<{
+            workspace: import("../../ids.ts").Id<"workspace">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly id: import("../../ids.ts").Id<"workspace">;
+            readonly sessions: number;
+            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 projectResources: boolean | null;
+            readonly trusted: boolean | null;
+            readonly addedBy: import("../../ids.ts").Id<"principal">;
+            readonly writers: readonly import("../../ids.ts").Id<"run">[];
+            readonly isolation: {
+                readonly session: import("../../ids.ts").Id<"session">;
+                readonly kind: "worktree";
+                readonly source: import("../../ids.ts").Id<"workspace">;
+                readonly branch: string;
+                readonly base: string;
+            } | null;
+        }>;
+        readonly authority: "participant";
+        readonly scope: "workspace";
+    };
+    readonly "workspace.catalog": {
+        readonly kind: "query";
+        readonly input: import("../../schema.ts").Schema<{
+            workspace: import("../../ids.ts").Id<"workspace">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            skills: {
+                description: string;
+                name: string;
+                location: string;
+                owner: string;
+            }[];
+            commands: {
+                category?: string | undefined;
+                keywords?: string[] | undefined;
+                description: string;
+                name: string;
+                title: string;
+                side: "core" | "client";
+                owner: string;
+                takesText: boolean;
+                completes: boolean;
+            }[];
+        }>;
+        readonly authority: "participant";
+        readonly scope: "workspace";
+    };
+    readonly "workspace.command": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            name: string;
+            workspace: import("../../ids.ts").Id<"workspace">;
+            text: string;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly output: string | null;
+            readonly kind: "ran";
+        } | {
+            readonly kind: "prompt";
+            readonly content: string | readonly ({
+                readonly text: string;
+                readonly kind: "text";
+            } | {
+                readonly name: string;
+                readonly blob: import("../../ids.ts").Id<"blob">;
+                readonly kind: "file";
+                readonly mime: string;
+            } | {
+                readonly blob?: import("../../ids.ts").Id<"blob"> | undefined;
+                readonly kind: "reference";
+                readonly path: string;
+            } | {
+                readonly name: string;
+                readonly kind: "skill";
+                readonly location: string;
+            } | {
+                readonly text: string;
+                readonly kind: "excerpt";
+                readonly source: {
+                    readonly kind: "diff";
+                    readonly path: string;
+                    readonly side: "old" | "new";
+                    readonly start: number;
+                    readonly end: number;
+                } | {
+                    readonly command?: string | undefined;
+                    readonly kind: "terminal";
+                } | {
+                    readonly url: string;
+                    readonly kind: "browser";
+                    readonly selector: string;
+                };
+            })[];
+        } | {
+            readonly kind: "unknown";
+        } | {
+            readonly message: string;
+            readonly kind: "failed";
+        }>;
+        readonly authority: "participant";
+        readonly scope: "workspace";
+    };
+    readonly "workspace.completeCommand": {
+        readonly kind: "query";
+        readonly input: import("../../schema.ts").Schema<{
+            name: string;
+            workspace: import("../../ids.ts").Id<"workspace">;
+            prefix: string;
+        }>;
+        readonly output: import("../../schema.ts").Schema<readonly {
+            readonly description?: string | undefined;
+            readonly value: string;
+            readonly label: string;
+        }[]>;
+        readonly authority: "participant";
+        readonly scope: "workspace";
+    };
+    readonly "mcp.watch": {
+        readonly kind: "watch";
+        readonly input: import("../../schema.ts").Schema<{
+            workspace: import("../../ids.ts").Id<"workspace">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            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 servers: readonly {
+                readonly description: string | null;
+                readonly name: string;
+                readonly state: {
+                    readonly kind: "disabled";
+                } | {
+                    readonly kind: "connecting";
+                } | {
+                    readonly kind: "connected";
+                    readonly tools: readonly {
+                        readonly description: string;
+                        readonly name: string;
+                        readonly exposure: "hidden" | "model" | "code" | "deferred";
+                    }[];
+                } | {
+                    readonly kind: "needs-sign-in";
+                } | {
+                    readonly message: string;
+                    readonly kind: "failed";
+                    readonly stderr: string | null;
+                };
+                readonly path: string;
+                readonly scope: "user" | "project";
+                readonly exposure: "hidden" | "model" | "code" | "deferred";
+                readonly override: string | null;
+                readonly transport: {
+                    readonly kind: "stdio";
+                    readonly command: string;
+                    readonly args: readonly string[];
+                } | {
+                    readonly url: string;
+                    readonly kind: "http";
+                };
+            }[];
+        }>;
+        readonly authority: "owner";
+        readonly scope: "workspace";
+    };
+    readonly "mcp.reconnect": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            workspace: import("../../ids.ts").Id<"workspace">;
+            server: string;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly kind: "updated";
+        } | {
+            readonly kind: "missing";
+        } | {
+            readonly message: string;
+            readonly kind: "invalid";
+        }>;
+        readonly authority: "owner";
+        readonly scope: "workspace";
+    };
+    readonly "mcp.setEnabled": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            workspace: import("../../ids.ts").Id<"workspace">;
+            enabled: boolean;
+            server: string;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly kind: "updated";
+        } | {
+            readonly kind: "missing";
+        } | {
+            readonly message: string;
+            readonly kind: "invalid";
+        }>;
+        readonly authority: "owner";
+        readonly scope: "workspace";
+    };
+    readonly "mcp.login": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            workspace: import("../../ids.ts").Id<"workspace">;
+            server: string;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            login: string;
+        }>;
+        readonly authority: "owner";
+        readonly scope: "workspace";
+    };
+    readonly "mcp.logout": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            workspace: import("../../ids.ts").Id<"workspace">;
+            server: string;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly kind: "updated";
+        } | {
+            readonly kind: "missing";
+        } | {
+            readonly message: string;
+            readonly kind: "invalid";
+        }>;
+        readonly authority: "owner";
+        readonly scope: "workspace";
+    };
+    readonly "mcp.add": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            workspace: import("../../ids.ts").Id<"workspace">;
+            scope: "user" | "project";
+            server: string;
+            config: {
+                type?: "stdio" | undefined;
+                description?: string | undefined;
+                exposure?: "hidden" | "deferred" | "direct" | "codemode" | "codemode-deferred" | undefined;
+                args?: string[] | undefined;
+                env?: Record<string, string> | undefined;
+                cwd?: string | undefined;
+                enabled?: boolean | undefined;
+                timeout?: number | undefined;
+                toolExposure?: Record<string, "hidden" | "deferred" | "direct" | "codemode" | "codemode-deferred"> | undefined;
+                command: string;
+            } | {
+                type?: "http" | "streamable-http" | undefined;
+                description?: string | undefined;
+                oauth?: {
+                    scope?: string | undefined;
+                    clientId?: string | undefined;
+                    clientSecret?: string | undefined;
+                    callbackPort?: number | undefined;
+                    callbackUrl?: string | undefined;
+                    clientName?: string | undefined;
+                    authServerMetadataUrl?: string | undefined;
+                } | undefined;
+                exposure?: "hidden" | "deferred" | "direct" | "codemode" | "codemode-deferred" | undefined;
+                headers?: Record<string, string> | undefined;
+                enabled?: boolean | undefined;
+                timeout?: number | undefined;
+                toolExposure?: Record<string, "hidden" | "deferred" | "direct" | "codemode" | "codemode-deferred"> | undefined;
+                url: string;
+            };
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly kind: "updated";
+        } | {
+            readonly kind: "missing";
+        } | {
+            readonly message: string;
+            readonly kind: "invalid";
+        }>;
+        readonly authority: "owner";
+        readonly scope: "workspace";
+    };
+    readonly "mcp.remove": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            workspace: import("../../ids.ts").Id<"workspace">;
+            scope: "user" | "project";
+            server: string;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly kind: "updated";
+        } | {
+            readonly kind: "missing";
+        } | {
+            readonly message: string;
+            readonly kind: "invalid";
+        }>;
+        readonly authority: "owner";
+        readonly scope: "workspace";
+    };
+    readonly "workspace.update": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            workspace: import("../../ids.ts").Id<"workspace">;
+            patch: {
+                projectResources?: boolean | null | undefined;
+            };
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            kind: "updated";
+        } | {
+            kind: "missing";
+        }>;
+        readonly authority: "owner";
+        readonly scope: "workspace";
+    };
+    readonly "workspace.reload": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            workspace: import("../../ids.ts").Id<"workspace">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            kind: "updated";
+        } | {
+            kind: "missing";
+        }>;
+        readonly authority: "owner";
+        readonly scope: "workspace";
+    };
+    readonly "workspace.changes": {
+        readonly kind: "query";
+        readonly input: import("../../schema.ts").Schema<{
+            workspace: import("../../ids.ts").Id<"workspace">;
+            source: {
+                run: import("../../ids.ts").Id<"run">;
+                kind: "run";
+            } | {
+                session: import("../../ids.ts").Id<"session">;
+                kind: "session";
+            };
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly revision: import("../../ids.ts").Id<"snapshot"> | import("../../ids.ts").Id<"git-revision">;
+            readonly files: readonly {
+                readonly from?: string | undefined;
+                readonly path: string;
+                readonly status: "added" | "modified" | "deleted" | "renamed" | "untracked" | "conflicted";
+                readonly stat: {
+                    readonly kind: "text";
+                    readonly removed: number;
+                    readonly added: number;
+                } | {
+                    readonly kind: "binary";
+                } | {
+                    readonly kind: "unknown";
+                };
+            }[];
+        }>;
+        readonly authority: "participant";
+        readonly scope: "workspace";
+    };
+    readonly "workspace.patches": {
+        readonly kind: "stream";
+        readonly input: import("../../schema.ts").Schema<{
+            options?: {
+                ignoreWhitespace?: boolean | undefined;
+            } | undefined;
+            workspace: import("../../ids.ts").Id<"workspace">;
+            source: {
+                run: import("../../ids.ts").Id<"run">;
+                kind: "run";
+            } | {
+                session: import("../../ids.ts").Id<"session">;
+                kind: "session";
+            };
+            paths: string[];
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly entries: {
+                readonly [x: string]: {
+                    readonly kind: "text";
+                    readonly path: string;
+                    readonly removed: number;
+                    readonly added: number;
+                    readonly status: "added" | "modified" | "deleted" | "renamed" | "untracked" | "conflicted";
+                    readonly patch: string;
+                    readonly digest: string;
+                    readonly fresh: boolean;
+                } | {
+                    readonly kind: "binary";
+                    readonly path: string;
+                    readonly status: "added" | "modified" | "deleted" | "renamed" | "untracked" | "conflicted";
+                    readonly digest: string;
+                    readonly fresh: boolean;
+                } | {
+                    readonly kind: "empty";
+                    readonly path: string;
+                    readonly status: "added" | "modified" | "deleted" | "renamed" | "untracked" | "conflicted";
+                    readonly digest: string;
+                    readonly fresh: boolean;
+                } | {
+                    readonly kind: "too-large";
+                    readonly limit: number;
+                    readonly path: string;
+                    readonly status: "added" | "modified" | "deleted" | "renamed" | "untracked" | "conflicted";
+                    readonly digest: string;
+                    readonly fresh: boolean;
+                } | {
+                    readonly kind: "failed";
+                    readonly reason: string;
+                    readonly path: string;
+                    readonly status: "added" | "modified" | "deleted" | "renamed" | "untracked" | "conflicted";
+                    readonly digest: string;
+                    readonly fresh: boolean;
+                };
+            };
+            readonly revision: import("../../ids.ts").Id<"snapshot"> | import("../../ids.ts").Id<"git-revision">;
+        }>;
+        readonly authority: "participant";
+        readonly scope: "workspace";
+    };
+    readonly "workspace.files": {
+        readonly kind: "query";
+        readonly input: import("../../schema.ts").Schema<{
+            workspace: import("../../ids.ts").Id<"workspace">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly kind: "available";
+        } | {
+            readonly kind: "unsupported";
+            readonly reason: string;
+        } | {
+            readonly kind: "denied";
+            readonly reason: string;
+        } | {
+            readonly kind: "unavailable";
+            readonly reason: string;
+            readonly retry: "allowed" | "manual";
+        }>;
+        readonly authority: "participant";
+        readonly scope: "workspace";
+    };
+    readonly "workspace.git": {
+        readonly kind: "query";
+        readonly input: import("../../schema.ts").Schema<{
+            workspace: import("../../ids.ts").Id<"workspace">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly kind: "available";
+        } | {
+            readonly kind: "unsupported";
+            readonly reason: string;
+        } | {
+            readonly kind: "denied";
+            readonly reason: string;
+        } | {
+            readonly kind: "unavailable";
+            readonly reason: string;
+            readonly retry: "allowed" | "manual";
+        }>;
+        readonly authority: "participant";
+        readonly scope: "workspace";
+    };
+    readonly "workspace.github": {
+        readonly kind: "query";
+        readonly input: import("../../schema.ts").Schema<{
+            workspace: import("../../ids.ts").Id<"workspace">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly kind: "available";
+        } | {
+            readonly kind: "unsupported";
+            readonly reason: string;
+        } | {
+            readonly kind: "denied";
+            readonly reason: string;
+        } | {
+            readonly kind: "unavailable";
+            readonly reason: string;
+            readonly retry: "allowed" | "manual";
+        }>;
+        readonly authority: "participant";
+        readonly scope: "workspace";
+    };
+    readonly "workspace.browser": {
+        readonly kind: "query";
+        readonly input: import("../../schema.ts").Schema<{
+            workspace: import("../../ids.ts").Id<"workspace">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly kind: "available";
+        } | {
+            readonly kind: "unsupported";
+            readonly reason: string;
+        } | {
+            readonly kind: "denied";
+            readonly reason: string;
+        } | {
+            readonly kind: "unavailable";
+            readonly reason: string;
+            readonly retry: "allowed" | "manual";
+        }>;
+        readonly authority: "participant";
+        readonly scope: "workspace";
+    };
+    readonly "jobs.start": {
+        readonly kind: "command";
+        readonly recovery: "replay";
+        readonly input: import("../../schema.ts").Schema<{
+            session?: import("../../ids.ts").Id<"session"> | undefined;
+            id?: import("../../ids.ts").Id<"job"> | undefined;
+            title?: string | undefined;
+            command?: string | undefined;
+            pty?: {
+                columns: number;
+                rows: number;
+            } | undefined;
+            workspace: import("../../ids.ts").Id<"workspace">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            key: import("../../ids.ts").Id<"job-key"> | null;
+            session: import("../../ids.ts").Id<"session"> | null;
+            id: import("../../ids.ts").Id<"job">;
+            title: string;
+            state: {
+                kind: "running";
+            } | {
+                kind: "exited";
+                reason: "exited" | "terminated" | "expired" | "host-lost";
+                code: number | null;
+            } | {
+                kind: "lost";
+            };
+            command: string;
+            pty: {
+                shell: string;
+                columns: number;
+                rows: number;
+            } | null;
+            startedAt: number;
+            endedAt: number | null;
+            tail: string;
+        }>;
+        readonly authority: "participant";
+        readonly scope: "workspace";
+    };
+    readonly "jobs.recover": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            key: import("../../ids.ts").Id<"job-key">;
+            workspace: import("../../ids.ts").Id<"workspace">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            key: import("../../ids.ts").Id<"job-key"> | null;
+            session: import("../../ids.ts").Id<"session"> | null;
+            id: import("../../ids.ts").Id<"job">;
+            title: string;
+            state: {
+                kind: "running";
+            } | {
+                kind: "exited";
+                reason: "exited" | "terminated" | "expired" | "host-lost";
+                code: number | null;
+            } | {
+                kind: "lost";
+            };
+            command: string;
+            pty: {
+                shell: string;
+                columns: number;
+                rows: number;
+            } | null;
+            startedAt: number;
+            endedAt: number | null;
+            tail: string;
+        } | {
+            kind: "ended";
+            end: {
+                kind: "exited";
+                reason: "exited" | "terminated" | "expired" | "host-lost";
+                code: number | null;
+            } | {
+                kind: "lost";
+            };
+        } | {
+            kind: "missing";
+        }>;
+        readonly authority: "participant";
+        readonly scope: "workspace";
+    };
+    readonly "jobs.list": {
+        readonly kind: "query";
+        readonly input: import("../../schema.ts").Schema<{
+            workspace: import("../../ids.ts").Id<"workspace">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            session: import("../../ids.ts").Id<"session"> | null;
+            id: import("../../ids.ts").Id<"job">;
+            title: string;
+            state: {
+                kind: "running";
+            } | {
+                kind: "exited";
+                reason: "exited" | "terminated" | "expired" | "host-lost";
+                code: number | null;
+            } | {
+                kind: "lost";
+            };
+            command: string;
+            pty: {
+                shell: string;
+                columns: number;
+                rows: number;
+            } | null;
+            startedAt: number;
+            endedAt: number | null;
+            tail: string;
+        }[]>;
+        readonly authority: "participant";
+        readonly scope: "workspace";
+    };
+    readonly "jobs.watch": {
+        readonly kind: "watch";
+        readonly input: import("../../schema.ts").Schema<{
+            workspace: import("../../ids.ts").Id<"workspace">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            kind: "jobs";
+            jobs: {
+                session: import("../../ids.ts").Id<"session"> | null;
+                id: import("../../ids.ts").Id<"job">;
+                title: string;
+                state: {
+                    kind: "running";
+                } | {
+                    kind: "exited";
+                    reason: "exited" | "terminated" | "expired" | "host-lost";
+                    code: number | null;
+                } | {
+                    kind: "lost";
+                };
+                command: string;
+                pty: {
+                    shell: string;
+                    columns: number;
+                    rows: number;
+                } | null;
+                startedAt: number;
+                endedAt: number | null;
+                tail: string;
+            }[];
+        } | {
+            job: {
+                session: import("../../ids.ts").Id<"session"> | null;
+                id: import("../../ids.ts").Id<"job">;
+                title: string;
+                state: {
+                    kind: "running";
+                } | {
+                    kind: "exited";
+                    reason: "exited" | "terminated" | "expired" | "host-lost";
+                    code: number | null;
+                } | {
+                    kind: "lost";
+                };
+                command: string;
+                pty: {
+                    shell: string;
+                    columns: number;
+                    rows: number;
+                } | null;
+                startedAt: number;
+                endedAt: number | null;
+                tail: string;
+            };
+            kind: "job";
+        } | {
+            id: import("../../ids.ts").Id<"job">;
+            kind: "forgotten";
+        }>;
+        readonly authority: "participant";
+        readonly scope: "workspace";
+    };
+    readonly "job.write": {
+        readonly kind: "command";
+        readonly recovery: "never";
+        readonly input: import("../../schema.ts").Schema<{
+            job: import("../../ids.ts").Id<"job">;
+            workspace: import("../../ids.ts").Id<"workspace">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<null>;
+        readonly authority: "participant";
+        readonly scope: "workspace";
+    };
+    readonly "job.output": {
+        readonly kind: "stream";
+        readonly input: import("../../schema.ts").Schema<{
+            job: import("../../ids.ts").Id<"job">;
+            workspace: import("../../ids.ts").Id<"workspace">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly stream?: "stderr" | undefined;
+            readonly kind: "bytes";
+            readonly data: Uint8Array<ArrayBufferLike>;
+        } | {
+            readonly kind: "gap";
+        } | {
+            readonly kind: "exit";
+            readonly code: number | null;
+        }>;
+        readonly authority: "participant";
+        readonly scope: "workspace";
+    };
+    readonly "job.resize": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            job: import("../../ids.ts").Id<"job">;
+            workspace: import("../../ids.ts").Id<"workspace">;
+            size: {
+                columns: number;
+                rows: number;
+            };
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            kind: "resized";
+        } | {
+            kind: "not-pty";
+        } | {
+            kind: "missing";
+        }>;
+        readonly authority: "participant";
+        readonly scope: "workspace";
+    };
+    readonly "job.idle": {
+        readonly kind: "query";
+        readonly input: import("../../schema.ts").Schema<{
+            job: import("../../ids.ts").Id<"job">;
+            workspace: import("../../ids.ts").Id<"workspace">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<boolean>;
+        readonly authority: "participant";
+        readonly scope: "workspace";
+    };
+    readonly "job.stop": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            job: import("../../ids.ts").Id<"job">;
+            workspace: import("../../ids.ts").Id<"workspace">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            kind: "requested";
+        } | {
+            kind: "settled";
+            outcome: {
+                kind: "exited";
+                reason: "exited" | "terminated" | "expired" | "host-lost";
+                code: number | null;
+            } | {
+                kind: "lost";
+            };
+        } | {
+            kind: "missing";
+        }>;
+        readonly authority: "participant";
+        readonly scope: "workspace";
+    };
+    readonly "job.settled": {
+        readonly kind: "query";
+        readonly wait: true;
+        readonly input: import("../../schema.ts").Schema<{
+            job: import("../../ids.ts").Id<"job">;
+            workspace: import("../../ids.ts").Id<"workspace">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly kind: "exited";
+            readonly reason: "exited" | "terminated" | "expired" | "host-lost";
+            readonly code: number | null;
+        } | {
+            readonly kind: "lost";
+        }>;
+        readonly authority: "participant";
+        readonly scope: "workspace";
+    };
+};