@nyte-ai/schema 0.0.0-stage → 0.0.18

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

@@ -0,0 +1,3411 @@
+export declare const SESSION_OPERATIONS: {
+    readonly "session.info": {
+        readonly kind: "query";
+        readonly input: import("../../schema.ts").Schema<{
+            session: import("../../ids.ts").Id<"session">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly name: string | null;
+            readonly call: import("../../ids.ts").Id<"call"> | null;
+            readonly workspace: import("../../ids.ts").Id<"workspace">;
+            readonly id: import("../../ids.ts").Id<"session">;
+            readonly parent: import("../../ids.ts").Id<"session"> | null;
+            readonly heads: readonly {
+                readonly name: import("../../ids.ts").Id<"head">;
+                readonly tip: {
+                    readonly kind: "start";
+                } | {
+                    readonly id: import("../../ids.ts").Id<"commit">;
+                    readonly kind: "commit";
+                };
+                readonly stack: {
+                    readonly stale: boolean;
+                    readonly parent: import("../../ids.ts").Id<"head">;
+                    readonly base: {
+                        readonly kind: "start";
+                    } | {
+                        readonly id: import("../../ids.ts").Id<"commit">;
+                        readonly kind: "commit";
+                    };
+                } | null;
+                readonly execution: {
+                    readonly kind: "idle";
+                    readonly lastRun: {
+                        readonly id: import("../../ids.ts").Id<"run">;
+                        readonly end: {
+                            readonly kind: "completed";
+                            readonly usage: {
+                                readonly output: number;
+                                readonly input: number;
+                                readonly cacheRead: number;
+                                readonly cacheWrite: number;
+                                readonly reasoning: number | null;
+                                readonly total: number;
+                                readonly cost: {
+                                    readonly output: number;
+                                    readonly input: number;
+                                    readonly cacheRead: number;
+                                    readonly cacheWrite: number;
+                                    readonly total: number;
+                                };
+                            };
+                        } | {
+                            readonly kind: "stopped";
+                        } | {
+                            readonly kind: "failed";
+                            readonly failure: {
+                                readonly retryAfterMs?: number | undefined;
+                                readonly message: string;
+                                readonly class: "provider" | "rate_limit" | "auth" | "quota" | "context_window" | "overloaded" | "network" | "aborted" | "runner";
+                            };
+                        };
+                        readonly endedAt: number;
+                    } | null;
+                } | {
+                    readonly run: {
+                        readonly head: import("../../ids.ts").Id<"head">;
+                        readonly id: import("../../ids.ts").Id<"run">;
+                        readonly configuration: {
+                            readonly kind: "exact";
+                            readonly thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                            readonly model: {
+                                readonly id: string;
+                                readonly provider: string;
+                            };
+                            readonly agent: string | null;
+                            readonly settings: {
+                                readonly [x: string]: import("../../json.ts").Json;
+                            };
+                            readonly settingsVersion: string;
+                        };
+                        readonly startedAt: number;
+                        readonly attempt: number;
+                        readonly origin: {
+                            readonly message: import("../../ids.ts").Id<"message">;
+                            readonly kind: "input";
+                        } | {
+                            readonly kind: "continuation";
+                            readonly from: "job" | "child" | "wake";
+                        };
+                    };
+                    readonly kind: "live";
+                    readonly phase: "responding" | "executing";
+                    readonly stopping: boolean;
+                } | {
+                    readonly run: {
+                        readonly head: import("../../ids.ts").Id<"head">;
+                        readonly id: import("../../ids.ts").Id<"run">;
+                        readonly configuration: {
+                            readonly kind: "exact";
+                            readonly thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                            readonly model: {
+                                readonly id: string;
+                                readonly provider: string;
+                            };
+                            readonly agent: string | null;
+                            readonly settings: {
+                                readonly [x: string]: import("../../json.ts").Json;
+                            };
+                            readonly settingsVersion: string;
+                        };
+                        readonly startedAt: number;
+                        readonly attempt: number;
+                        readonly origin: {
+                            readonly message: import("../../ids.ts").Id<"message">;
+                            readonly kind: "input";
+                        } | {
+                            readonly kind: "continuation";
+                            readonly from: "job" | "child" | "wake";
+                        };
+                    };
+                    readonly kind: "waiting";
+                    readonly on: {
+                        readonly deadline?: number | undefined;
+                        readonly session: import("../../ids.ts").Id<"session">;
+                        readonly run: import("../../ids.ts").Id<"run">;
+                        readonly kind: "run";
+                    } | {
+                        readonly deadline?: number | undefined;
+                        readonly job: import("../../ids.ts").Id<"job">;
+                        readonly kind: "job";
+                    } | {
+                        readonly deadline?: number | undefined;
+                        readonly part: import("../../ids.ts").Id<"part">;
+                        readonly kind: "part";
+                    } | {
+                        readonly deadline?: number | undefined;
+                        readonly kind: "timer";
+                        readonly until: number;
+                    };
+                } | {
+                    readonly run: {
+                        readonly head: import("../../ids.ts").Id<"head">;
+                        readonly id: import("../../ids.ts").Id<"run">;
+                        readonly configuration: {
+                            readonly kind: "exact";
+                            readonly thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                            readonly model: {
+                                readonly id: string;
+                                readonly provider: string;
+                            };
+                            readonly agent: string | null;
+                            readonly settings: {
+                                readonly [x: string]: import("../../json.ts").Json;
+                            };
+                            readonly settingsVersion: string;
+                        };
+                        readonly startedAt: number;
+                        readonly attempt: number;
+                        readonly origin: {
+                            readonly message: import("../../ids.ts").Id<"message">;
+                            readonly kind: "input";
+                        } | {
+                            readonly kind: "continuation";
+                            readonly from: "job" | "child" | "wake";
+                        };
+                    };
+                    readonly kind: "retrying";
+                    readonly reason: string;
+                    readonly until: number;
+                };
+                readonly unread: boolean;
+            }[];
+            readonly pinned: boolean;
+            readonly archived: boolean;
+            readonly activation: {
+                readonly kind: "active";
+            } | {
+                readonly kind: "inactive";
+            } | {
+                readonly workspace: import("../../ids.ts").Id<"workspace">;
+                readonly kind: "unavailable";
+                readonly reason: "unreachable" | "unsupported";
+            } | {
+                readonly message: string;
+                readonly kind: "failed";
+            };
+            readonly createdAt: number;
+            readonly lastActivityAt: number;
+        }>;
+        readonly authority: "participant";
+        readonly scope: "session";
+    };
+    readonly "session.update": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            session: import("../../ids.ts").Id<"session">;
+            patch: {
+                name?: string | null | undefined;
+                workspace?: import("../../ids.ts").Id<"workspace"> | undefined;
+                pinned?: boolean | undefined;
+                archived?: boolean | undefined;
+            };
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly kind: "updated";
+        } | {
+            readonly kind: "busy";
+            readonly runs: readonly import("../../ids.ts").Id<"run">[];
+        } | {
+            readonly kind: "unknown-workspace";
+        }>;
+        readonly authority: "participant";
+        readonly scope: "session";
+    };
+    readonly "session.remove": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            session: import("../../ids.ts").Id<"session">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly kind: "removed";
+        } | {
+            readonly kind: "busy";
+            readonly runs: readonly import("../../ids.ts").Id<"run">[];
+        } | {
+            readonly kind: "has-children";
+            readonly children: readonly import("../../ids.ts").Id<"session">[];
+        }>;
+        readonly authority: "participant";
+        readonly scope: "session";
+    };
+    readonly "session.stop": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            session: import("../../ids.ts").Id<"session">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            stopped: import("../../ids.ts").Id<"run">[];
+            withdrawn: import("../../ids.ts").Id<"message">[];
+        }>;
+        readonly authority: "participant";
+        readonly scope: "session";
+    };
+    readonly "session.command": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            name: string;
+            session: import("../../ids.ts").Id<"session">;
+            text: string;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly output: string | null;
+            readonly kind: "ran";
+        } | {
+            readonly receipt: import("../../ids.ts").Id<"receipt">;
+            readonly kind: "sent";
+        } | {
+            readonly kind: "unknown";
+        } | {
+            readonly message: string;
+            readonly kind: "failed";
+        }>;
+        readonly authority: "participant";
+        readonly scope: "session";
+    };
+    readonly "session.completeCommand": {
+        readonly kind: "query";
+        readonly input: import("../../schema.ts").Schema<{
+            name: string;
+            session: import("../../ids.ts").Id<"session">;
+            prefix: string;
+        }>;
+        readonly output: import("../../schema.ts").Schema<readonly {
+            readonly description?: string | undefined;
+            readonly value: string;
+            readonly label: string;
+        }[]>;
+        readonly authority: "participant";
+        readonly scope: "session";
+    };
+    readonly "head.send": {
+        readonly kind: "receipt";
+        readonly recovery: "replay";
+        readonly input: import("../../schema.ts").Schema<{
+            options?: {
+                replace?: import("../../ids.ts").Id<"message"> | undefined;
+                id?: import("../../ids.ts").Id<"receipt"> | undefined;
+                source?: {
+                    kind: "user";
+                } | {
+                    session: import("../../ids.ts").Id<"session">;
+                    kind: "child";
+                    end: "failed" | "completed" | "stopped";
+                } | {
+                    job: import("../../ids.ts").Id<"job">;
+                    kind: "job";
+                } | {
+                    kind: "shell";
+                } | {
+                    command?: string | undefined;
+                    kind: "action";
+                    label: string;
+                } | 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;
+                position?: {
+                    kind: "last";
+                } | {
+                    message: import("../../ids.ts").Id<"message">;
+                    kind: "before";
+                } | undefined;
+                running?: "refuse" | "stop" | undefined;
+                abandoned?: "keep" | {
+                    summarize: {
+                        instructions?: string | undefined;
+                    };
+                } | undefined;
+                expect?: import("../../ids.ts").Id<"revision"> | undefined;
+                delivery?: "steer" | "queue" | "attach" | undefined;
+            } | undefined;
+            session: import("../../ids.ts").Id<"session">;
+            head: import("../../ids.ts").Id<"head">;
+            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<{
+            message: import("../../ids.ts").Id<"message">;
+            receipt: import("../../ids.ts").Id<"receipt">;
+        }>;
+        readonly authority: "participant";
+        readonly scope: "session";
+    };
+    readonly "head.configure": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            session: import("../../ids.ts").Id<"session">;
+            head: import("../../ids.ts").Id<"head">;
+            patch: {
+                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;
+            };
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly revision: import("../../ids.ts").Id<"revision">;
+            readonly kind: "configured";
+            readonly selected: {
+                readonly kind: "exact";
+                readonly thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                readonly model: {
+                    readonly id: string;
+                    readonly provider: string;
+                };
+                readonly agent: string | null;
+                readonly settings: {
+                    readonly [x: string]: import("../../json.ts").Json;
+                };
+                readonly settingsVersion: string;
+            };
+        } | {
+            readonly kind: "unknown-model";
+            readonly model: {
+                readonly id: string;
+                readonly provider: string;
+            };
+        } | {
+            readonly kind: "unknown-agent";
+            readonly agent: string;
+        } | {
+            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 authority: "participant";
+        readonly scope: "session";
+    };
+    readonly "head.view": {
+        readonly kind: "query";
+        readonly input: import("../../schema.ts").Schema<{
+            options?: {
+                tail?: number | undefined;
+            } | undefined;
+            session: import("../../ids.ts").Id<"session">;
+            head: import("../../ids.ts").Id<"head">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly revision: import("../../ids.ts").Id<"revision"> | null;
+            readonly seq: import("../../ids.ts").Seq;
+            readonly configuration: {
+                readonly selected: {
+                    readonly kind: "exact";
+                    readonly thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                    readonly model: {
+                        readonly id: string;
+                        readonly provider: string;
+                    };
+                    readonly agent: string | null;
+                    readonly settings: {
+                        readonly [x: string]: import("../../json.ts").Json;
+                    };
+                    readonly settingsVersion: string;
+                } | null;
+                readonly effective: {
+                    readonly kind: "exact";
+                    readonly thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                    readonly model: {
+                        readonly id: string;
+                        readonly provider: string;
+                    };
+                    readonly agent: string | null;
+                    readonly settings: {
+                        readonly [x: string]: import("../../json.ts").Json;
+                    };
+                    readonly settingsVersion: string;
+                } | null;
+            };
+            readonly heads: readonly {
+                readonly name: import("../../ids.ts").Id<"head">;
+                readonly tip: {
+                    readonly kind: "start";
+                } | {
+                    readonly id: import("../../ids.ts").Id<"commit">;
+                    readonly kind: "commit";
+                };
+                readonly stack: {
+                    readonly stale: boolean;
+                    readonly parent: import("../../ids.ts").Id<"head">;
+                    readonly base: {
+                        readonly kind: "start";
+                    } | {
+                        readonly id: import("../../ids.ts").Id<"commit">;
+                        readonly kind: "commit";
+                    };
+                } | null;
+                readonly execution: {
+                    readonly kind: "idle";
+                    readonly lastRun: {
+                        readonly id: import("../../ids.ts").Id<"run">;
+                        readonly end: {
+                            readonly kind: "completed";
+                            readonly usage: {
+                                readonly output: number;
+                                readonly input: number;
+                                readonly cacheRead: number;
+                                readonly cacheWrite: number;
+                                readonly reasoning: number | null;
+                                readonly total: number;
+                                readonly cost: {
+                                    readonly output: number;
+                                    readonly input: number;
+                                    readonly cacheRead: number;
+                                    readonly cacheWrite: number;
+                                    readonly total: number;
+                                };
+                            };
+                        } | {
+                            readonly kind: "stopped";
+                        } | {
+                            readonly kind: "failed";
+                            readonly failure: {
+                                readonly retryAfterMs?: number | undefined;
+                                readonly message: string;
+                                readonly class: "provider" | "rate_limit" | "auth" | "quota" | "context_window" | "overloaded" | "network" | "aborted" | "runner";
+                            };
+                        };
+                        readonly endedAt: number;
+                    } | null;
+                } | {
+                    readonly run: {
+                        readonly head: import("../../ids.ts").Id<"head">;
+                        readonly id: import("../../ids.ts").Id<"run">;
+                        readonly configuration: {
+                            readonly kind: "exact";
+                            readonly thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                            readonly model: {
+                                readonly id: string;
+                                readonly provider: string;
+                            };
+                            readonly agent: string | null;
+                            readonly settings: {
+                                readonly [x: string]: import("../../json.ts").Json;
+                            };
+                            readonly settingsVersion: string;
+                        };
+                        readonly startedAt: number;
+                        readonly attempt: number;
+                        readonly origin: {
+                            readonly message: import("../../ids.ts").Id<"message">;
+                            readonly kind: "input";
+                        } | {
+                            readonly kind: "continuation";
+                            readonly from: "job" | "child" | "wake";
+                        };
+                    };
+                    readonly kind: "live";
+                    readonly phase: "responding" | "executing";
+                    readonly stopping: boolean;
+                } | {
+                    readonly run: {
+                        readonly head: import("../../ids.ts").Id<"head">;
+                        readonly id: import("../../ids.ts").Id<"run">;
+                        readonly configuration: {
+                            readonly kind: "exact";
+                            readonly thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                            readonly model: {
+                                readonly id: string;
+                                readonly provider: string;
+                            };
+                            readonly agent: string | null;
+                            readonly settings: {
+                                readonly [x: string]: import("../../json.ts").Json;
+                            };
+                            readonly settingsVersion: string;
+                        };
+                        readonly startedAt: number;
+                        readonly attempt: number;
+                        readonly origin: {
+                            readonly message: import("../../ids.ts").Id<"message">;
+                            readonly kind: "input";
+                        } | {
+                            readonly kind: "continuation";
+                            readonly from: "job" | "child" | "wake";
+                        };
+                    };
+                    readonly kind: "waiting";
+                    readonly on: {
+                        readonly deadline?: number | undefined;
+                        readonly session: import("../../ids.ts").Id<"session">;
+                        readonly run: import("../../ids.ts").Id<"run">;
+                        readonly kind: "run";
+                    } | {
+                        readonly deadline?: number | undefined;
+                        readonly job: import("../../ids.ts").Id<"job">;
+                        readonly kind: "job";
+                    } | {
+                        readonly deadline?: number | undefined;
+                        readonly part: import("../../ids.ts").Id<"part">;
+                        readonly kind: "part";
+                    } | {
+                        readonly deadline?: number | undefined;
+                        readonly kind: "timer";
+                        readonly until: number;
+                    };
+                } | {
+                    readonly run: {
+                        readonly head: import("../../ids.ts").Id<"head">;
+                        readonly id: import("../../ids.ts").Id<"run">;
+                        readonly configuration: {
+                            readonly kind: "exact";
+                            readonly thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                            readonly model: {
+                                readonly id: string;
+                                readonly provider: string;
+                            };
+                            readonly agent: string | null;
+                            readonly settings: {
+                                readonly [x: string]: import("../../json.ts").Json;
+                            };
+                            readonly settingsVersion: string;
+                        };
+                        readonly startedAt: number;
+                        readonly attempt: number;
+                        readonly origin: {
+                            readonly message: import("../../ids.ts").Id<"message">;
+                            readonly kind: "input";
+                        } | {
+                            readonly kind: "continuation";
+                            readonly from: "job" | "child" | "wake";
+                        };
+                    };
+                    readonly kind: "retrying";
+                    readonly reason: string;
+                    readonly until: number;
+                };
+                readonly unread: boolean;
+            }[];
+            readonly messages: readonly ({
+                readonly at: number;
+                readonly turn: import("../../ids.ts").Id<"turn">;
+                readonly id: import("../../ids.ts").Id<"message">;
+                readonly kind: "user";
+                readonly source: {
+                    readonly kind: "user";
+                } | {
+                    readonly session: import("../../ids.ts").Id<"session">;
+                    readonly kind: "child";
+                    readonly end: "failed" | "completed" | "stopped";
+                } | {
+                    readonly job: import("../../ids.ts").Id<"job">;
+                    readonly kind: "job";
+                } | {
+                    readonly kind: "shell";
+                } | {
+                    readonly command?: string | undefined;
+                    readonly kind: "action";
+                    readonly label: string;
+                };
+                readonly delivery: "steer" | "queue" | "attach";
+                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 status: {
+                    readonly kind: "unsent";
+                    readonly retrying: {
+                        readonly at: number;
+                        readonly reason: string;
+                    } | null;
+                    readonly attempts: number;
+                } | {
+                    readonly kind: "pending";
+                    readonly schedule: {
+                        readonly run: import("../../ids.ts").Id<"run">;
+                        readonly kind: "joined";
+                    } | {
+                        readonly kind: "next-turn";
+                        readonly reason: "requested" | "idle" | "run-ended" | "configuration";
+                    } | {
+                        readonly kind: "attached";
+                    } | {
+                        readonly kind: "deciding";
+                    };
+                    readonly covered: boolean;
+                } | {
+                    readonly run: import("../../ids.ts").Id<"run"> | null;
+                    readonly commit: import("../../ids.ts").Id<"commit">;
+                    readonly kind: "landed";
+                    readonly replaced: {
+                        readonly stopped: import("../../ids.ts").Id<"run"> | null;
+                        readonly previous: import("../../ids.ts").Id<"message">;
+                    } | null;
+                };
+                readonly siblings: {
+                    readonly count: number;
+                    readonly index: number;
+                    readonly ids: readonly import("../../ids.ts").Id<"commit">[];
+                };
+            } | {
+                readonly at: number;
+                readonly turn: import("../../ids.ts").Id<"turn">;
+                readonly part: import("../../ids.ts").Id<"part">;
+                readonly id: import("../../ids.ts").Id<"message">;
+                readonly role: "answer" | "step" | "note";
+                readonly kind: "part";
+                readonly state: unknown;
+                readonly partKind: string;
+                readonly version: number;
+                readonly status: {
+                    readonly waiting?: import("../../ids.ts").Id<"call"> | undefined;
+                    readonly answer?: {
+                        readonly input: import("../../json.ts").Json;
+                        readonly action: string;
+                    } | undefined;
+                    readonly run: import("../../ids.ts").Id<"run"> | null;
+                    readonly kind: "live";
+                } | {
+                    readonly run: import("../../ids.ts").Id<"run">;
+                    readonly kind: "waiting";
+                    readonly on: {
+                        readonly deadline?: number | undefined;
+                        readonly session: import("../../ids.ts").Id<"session">;
+                        readonly run: import("../../ids.ts").Id<"run">;
+                        readonly kind: "run";
+                    } | {
+                        readonly deadline?: number | undefined;
+                        readonly job: import("../../ids.ts").Id<"job">;
+                        readonly kind: "job";
+                    } | {
+                        readonly deadline?: number | undefined;
+                        readonly part: import("../../ids.ts").Id<"part">;
+                        readonly kind: "part";
+                    } | {
+                        readonly deadline?: number | undefined;
+                        readonly kind: "timer";
+                        readonly until: number;
+                    };
+                } | {
+                    readonly commit: import("../../ids.ts").Id<"commit">;
+                    readonly kind: "settled";
+                    readonly endedAt: number;
+                } | {
+                    readonly run: import("../../ids.ts").Id<"run"> | null;
+                    readonly kind: "failed";
+                    readonly failure: {
+                        readonly retryAfterMs?: number | undefined;
+                        readonly message: string;
+                        readonly class: "provider" | "rate_limit" | "auth" | "quota" | "context_window" | "overloaded" | "network" | "aborted" | "runner";
+                    };
+                };
+            })[];
+            readonly usage: {
+                readonly output: number;
+                readonly input: number;
+                readonly cacheRead: number;
+                readonly cacheWrite: number;
+                readonly reasoning: number | null;
+                readonly total: number;
+                readonly cost: {
+                    readonly output: number;
+                    readonly input: number;
+                    readonly cacheRead: number;
+                    readonly cacheWrite: number;
+                    readonly total: number;
+                };
+            };
+            readonly execution: {
+                readonly kind: "idle";
+                readonly lastRun: {
+                    readonly id: import("../../ids.ts").Id<"run">;
+                    readonly end: {
+                        readonly kind: "completed";
+                        readonly usage: {
+                            readonly output: number;
+                            readonly input: number;
+                            readonly cacheRead: number;
+                            readonly cacheWrite: number;
+                            readonly reasoning: number | null;
+                            readonly total: number;
+                            readonly cost: {
+                                readonly output: number;
+                                readonly input: number;
+                                readonly cacheRead: number;
+                                readonly cacheWrite: number;
+                                readonly total: number;
+                            };
+                        };
+                    } | {
+                        readonly kind: "stopped";
+                    } | {
+                        readonly kind: "failed";
+                        readonly failure: {
+                            readonly retryAfterMs?: number | undefined;
+                            readonly message: string;
+                            readonly class: "provider" | "rate_limit" | "auth" | "quota" | "context_window" | "overloaded" | "network" | "aborted" | "runner";
+                        };
+                    };
+                    readonly endedAt: number;
+                } | null;
+            } | {
+                readonly run: {
+                    readonly head: import("../../ids.ts").Id<"head">;
+                    readonly id: import("../../ids.ts").Id<"run">;
+                    readonly configuration: {
+                        readonly kind: "exact";
+                        readonly thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                        readonly model: {
+                            readonly id: string;
+                            readonly provider: string;
+                        };
+                        readonly agent: string | null;
+                        readonly settings: {
+                            readonly [x: string]: import("../../json.ts").Json;
+                        };
+                        readonly settingsVersion: string;
+                    };
+                    readonly startedAt: number;
+                    readonly attempt: number;
+                    readonly origin: {
+                        readonly message: import("../../ids.ts").Id<"message">;
+                        readonly kind: "input";
+                    } | {
+                        readonly kind: "continuation";
+                        readonly from: "job" | "child" | "wake";
+                    };
+                };
+                readonly kind: "live";
+                readonly phase: "responding" | "executing";
+                readonly stopping: boolean;
+            } | {
+                readonly run: {
+                    readonly head: import("../../ids.ts").Id<"head">;
+                    readonly id: import("../../ids.ts").Id<"run">;
+                    readonly configuration: {
+                        readonly kind: "exact";
+                        readonly thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                        readonly model: {
+                            readonly id: string;
+                            readonly provider: string;
+                        };
+                        readonly agent: string | null;
+                        readonly settings: {
+                            readonly [x: string]: import("../../json.ts").Json;
+                        };
+                        readonly settingsVersion: string;
+                    };
+                    readonly startedAt: number;
+                    readonly attempt: number;
+                    readonly origin: {
+                        readonly message: import("../../ids.ts").Id<"message">;
+                        readonly kind: "input";
+                    } | {
+                        readonly kind: "continuation";
+                        readonly from: "job" | "child" | "wake";
+                    };
+                };
+                readonly kind: "waiting";
+                readonly on: {
+                    readonly deadline?: number | undefined;
+                    readonly session: import("../../ids.ts").Id<"session">;
+                    readonly run: import("../../ids.ts").Id<"run">;
+                    readonly kind: "run";
+                } | {
+                    readonly deadline?: number | undefined;
+                    readonly job: import("../../ids.ts").Id<"job">;
+                    readonly kind: "job";
+                } | {
+                    readonly deadline?: number | undefined;
+                    readonly part: import("../../ids.ts").Id<"part">;
+                    readonly kind: "part";
+                } | {
+                    readonly deadline?: number | undefined;
+                    readonly kind: "timer";
+                    readonly until: number;
+                };
+            } | {
+                readonly run: {
+                    readonly head: import("../../ids.ts").Id<"head">;
+                    readonly id: import("../../ids.ts").Id<"run">;
+                    readonly configuration: {
+                        readonly kind: "exact";
+                        readonly thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                        readonly model: {
+                            readonly id: string;
+                            readonly provider: string;
+                        };
+                        readonly agent: string | null;
+                        readonly settings: {
+                            readonly [x: string]: import("../../json.ts").Json;
+                        };
+                        readonly settingsVersion: string;
+                    };
+                    readonly startedAt: number;
+                    readonly attempt: number;
+                    readonly origin: {
+                        readonly message: import("../../ids.ts").Id<"message">;
+                        readonly kind: "input";
+                    } | {
+                        readonly kind: "continuation";
+                        readonly from: "job" | "child" | "wake";
+                    };
+                };
+                readonly kind: "retrying";
+                readonly reason: string;
+                readonly until: number;
+            };
+            readonly activation: {
+                readonly kind: "active";
+            } | {
+                readonly kind: "inactive";
+            } | {
+                readonly workspace: import("../../ids.ts").Id<"workspace">;
+                readonly kind: "unavailable";
+                readonly reason: "unreachable" | "unsupported";
+            } | {
+                readonly message: string;
+                readonly kind: "failed";
+            };
+            readonly catalog: {
+                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 skills: readonly {
+                    readonly description: string;
+                    readonly name: string;
+                    readonly location: string;
+                    readonly owner: string;
+                }[];
+                readonly commands: readonly {
+                    readonly category?: string | undefined;
+                    readonly keywords?: readonly string[] | undefined;
+                    readonly description: string;
+                    readonly name: string;
+                    readonly title: string;
+                    readonly side: "core" | "client";
+                    readonly owner: string;
+                    readonly takesText: boolean;
+                    readonly completes: boolean;
+                }[];
+                readonly agents: readonly {
+                    readonly description: string | null;
+                    readonly id: string;
+                    readonly model: {
+                        readonly id: string;
+                        readonly provider: string;
+                    } | null;
+                    readonly owner: string;
+                    readonly mode: "all" | "primary" | "subagent";
+                }[];
+                readonly tools: readonly {
+                    readonly description: string;
+                    readonly output: {
+                        readonly [x: string]: import("../../json.ts").Json;
+                    } | null;
+                    readonly name: string;
+                    readonly owner: string;
+                    readonly namespace: string | null;
+                    readonly parameters: {
+                        readonly [x: string]: import("../../json.ts").Json;
+                    };
+                    readonly exposure: "model" | "code" | "deferred" | "hidden";
+                }[];
+            };
+            readonly parts: readonly {
+                readonly id: import("../../ids.ts").Id<"part">;
+                readonly state: import("../../json.ts").Json;
+                readonly partKind: string;
+                readonly owner: string | null;
+                readonly version: number;
+                readonly status: {
+                    readonly waiting?: import("../../ids.ts").Id<"call"> | undefined;
+                    readonly answer?: {
+                        readonly input: import("../../json.ts").Json;
+                        readonly action: string;
+                    } | undefined;
+                    readonly run: import("../../ids.ts").Id<"run"> | null;
+                    readonly kind: "live";
+                } | {
+                    readonly run: import("../../ids.ts").Id<"run">;
+                    readonly kind: "waiting";
+                    readonly on: {
+                        readonly deadline?: number | undefined;
+                        readonly session: import("../../ids.ts").Id<"session">;
+                        readonly run: import("../../ids.ts").Id<"run">;
+                        readonly kind: "run";
+                    } | {
+                        readonly deadline?: number | undefined;
+                        readonly job: import("../../ids.ts").Id<"job">;
+                        readonly kind: "job";
+                    } | {
+                        readonly deadline?: number | undefined;
+                        readonly part: import("../../ids.ts").Id<"part">;
+                        readonly kind: "part";
+                    } | {
+                        readonly deadline?: number | undefined;
+                        readonly kind: "timer";
+                        readonly until: number;
+                    };
+                } | {
+                    readonly commit: import("../../ids.ts").Id<"commit">;
+                    readonly kind: "settled";
+                    readonly endedAt: number;
+                } | {
+                    readonly run: import("../../ids.ts").Id<"run"> | null;
+                    readonly kind: "failed";
+                    readonly failure: {
+                        readonly retryAfterMs?: number | undefined;
+                        readonly message: string;
+                        readonly class: "provider" | "rate_limit" | "auth" | "quota" | "context_window" | "overloaded" | "network" | "aborted" | "runner";
+                    };
+                };
+                readonly placement: {
+                    readonly role: "answer" | "step" | "note";
+                    readonly kind: "transcript";
+                } | {
+                    readonly kind: "modal";
+                } | {
+                    readonly [x: string]: import("../../json.ts").Json;
+                    readonly kind: string;
+                };
+            }[];
+            readonly changes: readonly {
+                readonly from?: string | undefined;
+                readonly path: string;
+                readonly removed: number;
+                readonly added: number;
+                readonly status: "added" | "modified" | "deleted" | "renamed" | "untracked" | "conflicted";
+            }[];
+            readonly background: readonly {
+                readonly id: string;
+                readonly title: string;
+                readonly kind: "job" | "page" | "child";
+                readonly state: "failed" | "waiting" | "working" | "done";
+                readonly startedBy: import("../../ids.ts").Id<"call"> | null;
+            }[];
+            readonly context: {
+                readonly tokens: number;
+                readonly window: number;
+                readonly lastRequest: {
+                    readonly output: number;
+                    readonly input: number;
+                    readonly cacheRead: number;
+                    readonly cacheWrite: number;
+                    readonly reasoning: number | null;
+                    readonly total: number;
+                    readonly cost: {
+                        readonly output: number;
+                        readonly input: number;
+                        readonly cacheRead: number;
+                        readonly cacheWrite: number;
+                        readonly total: number;
+                    };
+                } | null;
+            };
+            readonly turns: readonly {
+                readonly run: import("../../ids.ts").Id<"run"> | null;
+                readonly id: import("../../ids.ts").Id<"turn">;
+                readonly state: {
+                    readonly kind: "working";
+                    readonly activity: string | null;
+                } | {
+                    readonly kind: "waiting";
+                    readonly on: {
+                        readonly deadline?: number | undefined;
+                        readonly session: import("../../ids.ts").Id<"session">;
+                        readonly run: import("../../ids.ts").Id<"run">;
+                        readonly kind: "run";
+                    } | {
+                        readonly deadline?: number | undefined;
+                        readonly job: import("../../ids.ts").Id<"job">;
+                        readonly kind: "job";
+                    } | {
+                        readonly deadline?: number | undefined;
+                        readonly part: import("../../ids.ts").Id<"part">;
+                        readonly kind: "part";
+                    } | {
+                        readonly deadline?: number | undefined;
+                        readonly kind: "timer";
+                        readonly until: number;
+                    };
+                } | {
+                    readonly kind: "ended";
+                    readonly end: {
+                        readonly kind: "completed";
+                        readonly usage: {
+                            readonly output: number;
+                            readonly input: number;
+                            readonly cacheRead: number;
+                            readonly cacheWrite: number;
+                            readonly reasoning: number | null;
+                            readonly total: number;
+                            readonly cost: {
+                                readonly output: number;
+                                readonly input: number;
+                                readonly cacheRead: number;
+                                readonly cacheWrite: number;
+                                readonly total: number;
+                            };
+                        };
+                    } | {
+                        readonly kind: "stopped";
+                    } | {
+                        readonly kind: "failed";
+                        readonly failure: {
+                            readonly retryAfterMs?: number | undefined;
+                            readonly message: string;
+                            readonly class: "provider" | "rate_limit" | "auth" | "quota" | "context_window" | "overloaded" | "network" | "aborted" | "runner";
+                        };
+                    };
+                };
+                readonly summary: {
+                    readonly failed: number;
+                    readonly stopped: number;
+                    readonly removed: number;
+                    readonly added: number;
+                    readonly byClass: {
+                        readonly shell: {
+                            readonly paths: readonly string[];
+                            readonly count: number;
+                        };
+                        readonly edit: {
+                            readonly paths: readonly string[];
+                            readonly count: number;
+                        };
+                        readonly custom: {
+                            readonly paths: readonly string[];
+                            readonly count: number;
+                        };
+                        readonly read: {
+                            readonly paths: readonly string[];
+                            readonly count: number;
+                        };
+                        readonly list: {
+                            readonly paths: readonly string[];
+                            readonly count: number;
+                        };
+                        readonly delegate: {
+                            readonly paths: readonly string[];
+                            readonly count: number;
+                        };
+                    };
+                };
+                readonly startedAt: number;
+                readonly endedAt: number | null;
+                readonly prompt: import("../../ids.ts").Id<"message"> | null;
+                readonly steps: number;
+                readonly thinkingOnly: boolean;
+            }[];
+        }>;
+        readonly authority: "participant";
+        readonly scope: "session";
+    };
+    readonly "head.watch": {
+        readonly kind: "watch";
+        readonly input: import("../../schema.ts").Schema<{
+            options?: {
+                tail?: number | undefined;
+            } | undefined;
+            session: import("../../ids.ts").Id<"session">;
+            head: import("../../ids.ts").Id<"head">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly kind: "view";
+            readonly view: {
+                readonly revision: import("../../ids.ts").Id<"revision"> | null;
+                readonly seq: import("../../ids.ts").Seq;
+                readonly configuration: {
+                    readonly selected: {
+                        readonly kind: "exact";
+                        readonly thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                        readonly model: {
+                            readonly id: string;
+                            readonly provider: string;
+                        };
+                        readonly agent: string | null;
+                        readonly settings: {
+                            readonly [x: string]: import("../../json.ts").Json;
+                        };
+                        readonly settingsVersion: string;
+                    } | null;
+                    readonly effective: {
+                        readonly kind: "exact";
+                        readonly thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                        readonly model: {
+                            readonly id: string;
+                            readonly provider: string;
+                        };
+                        readonly agent: string | null;
+                        readonly settings: {
+                            readonly [x: string]: import("../../json.ts").Json;
+                        };
+                        readonly settingsVersion: string;
+                    } | null;
+                };
+                readonly heads: readonly {
+                    readonly name: import("../../ids.ts").Id<"head">;
+                    readonly tip: {
+                        readonly kind: "start";
+                    } | {
+                        readonly id: import("../../ids.ts").Id<"commit">;
+                        readonly kind: "commit";
+                    };
+                    readonly stack: {
+                        readonly stale: boolean;
+                        readonly parent: import("../../ids.ts").Id<"head">;
+                        readonly base: {
+                            readonly kind: "start";
+                        } | {
+                            readonly id: import("../../ids.ts").Id<"commit">;
+                            readonly kind: "commit";
+                        };
+                    } | null;
+                    readonly execution: {
+                        readonly kind: "idle";
+                        readonly lastRun: {
+                            readonly id: import("../../ids.ts").Id<"run">;
+                            readonly end: {
+                                readonly kind: "completed";
+                                readonly usage: {
+                                    readonly output: number;
+                                    readonly input: number;
+                                    readonly cacheRead: number;
+                                    readonly cacheWrite: number;
+                                    readonly reasoning: number | null;
+                                    readonly total: number;
+                                    readonly cost: {
+                                        readonly output: number;
+                                        readonly input: number;
+                                        readonly cacheRead: number;
+                                        readonly cacheWrite: number;
+                                        readonly total: number;
+                                    };
+                                };
+                            } | {
+                                readonly kind: "stopped";
+                            } | {
+                                readonly kind: "failed";
+                                readonly failure: {
+                                    readonly retryAfterMs?: number | undefined;
+                                    readonly message: string;
+                                    readonly class: "provider" | "rate_limit" | "auth" | "quota" | "context_window" | "overloaded" | "network" | "aborted" | "runner";
+                                };
+                            };
+                            readonly endedAt: number;
+                        } | null;
+                    } | {
+                        readonly run: {
+                            readonly head: import("../../ids.ts").Id<"head">;
+                            readonly id: import("../../ids.ts").Id<"run">;
+                            readonly configuration: {
+                                readonly kind: "exact";
+                                readonly thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                                readonly model: {
+                                    readonly id: string;
+                                    readonly provider: string;
+                                };
+                                readonly agent: string | null;
+                                readonly settings: {
+                                    readonly [x: string]: import("../../json.ts").Json;
+                                };
+                                readonly settingsVersion: string;
+                            };
+                            readonly startedAt: number;
+                            readonly attempt: number;
+                            readonly origin: {
+                                readonly message: import("../../ids.ts").Id<"message">;
+                                readonly kind: "input";
+                            } | {
+                                readonly kind: "continuation";
+                                readonly from: "job" | "child" | "wake";
+                            };
+                        };
+                        readonly kind: "live";
+                        readonly phase: "responding" | "executing";
+                        readonly stopping: boolean;
+                    } | {
+                        readonly run: {
+                            readonly head: import("../../ids.ts").Id<"head">;
+                            readonly id: import("../../ids.ts").Id<"run">;
+                            readonly configuration: {
+                                readonly kind: "exact";
+                                readonly thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                                readonly model: {
+                                    readonly id: string;
+                                    readonly provider: string;
+                                };
+                                readonly agent: string | null;
+                                readonly settings: {
+                                    readonly [x: string]: import("../../json.ts").Json;
+                                };
+                                readonly settingsVersion: string;
+                            };
+                            readonly startedAt: number;
+                            readonly attempt: number;
+                            readonly origin: {
+                                readonly message: import("../../ids.ts").Id<"message">;
+                                readonly kind: "input";
+                            } | {
+                                readonly kind: "continuation";
+                                readonly from: "job" | "child" | "wake";
+                            };
+                        };
+                        readonly kind: "waiting";
+                        readonly on: {
+                            readonly deadline?: number | undefined;
+                            readonly session: import("../../ids.ts").Id<"session">;
+                            readonly run: import("../../ids.ts").Id<"run">;
+                            readonly kind: "run";
+                        } | {
+                            readonly deadline?: number | undefined;
+                            readonly job: import("../../ids.ts").Id<"job">;
+                            readonly kind: "job";
+                        } | {
+                            readonly deadline?: number | undefined;
+                            readonly part: import("../../ids.ts").Id<"part">;
+                            readonly kind: "part";
+                        } | {
+                            readonly deadline?: number | undefined;
+                            readonly kind: "timer";
+                            readonly until: number;
+                        };
+                    } | {
+                        readonly run: {
+                            readonly head: import("../../ids.ts").Id<"head">;
+                            readonly id: import("../../ids.ts").Id<"run">;
+                            readonly configuration: {
+                                readonly kind: "exact";
+                                readonly thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                                readonly model: {
+                                    readonly id: string;
+                                    readonly provider: string;
+                                };
+                                readonly agent: string | null;
+                                readonly settings: {
+                                    readonly [x: string]: import("../../json.ts").Json;
+                                };
+                                readonly settingsVersion: string;
+                            };
+                            readonly startedAt: number;
+                            readonly attempt: number;
+                            readonly origin: {
+                                readonly message: import("../../ids.ts").Id<"message">;
+                                readonly kind: "input";
+                            } | {
+                                readonly kind: "continuation";
+                                readonly from: "job" | "child" | "wake";
+                            };
+                        };
+                        readonly kind: "retrying";
+                        readonly reason: string;
+                        readonly until: number;
+                    };
+                    readonly unread: boolean;
+                }[];
+                readonly messages: readonly ({
+                    readonly at: number;
+                    readonly turn: import("../../ids.ts").Id<"turn">;
+                    readonly id: import("../../ids.ts").Id<"message">;
+                    readonly kind: "user";
+                    readonly source: {
+                        readonly kind: "user";
+                    } | {
+                        readonly session: import("../../ids.ts").Id<"session">;
+                        readonly kind: "child";
+                        readonly end: "failed" | "completed" | "stopped";
+                    } | {
+                        readonly job: import("../../ids.ts").Id<"job">;
+                        readonly kind: "job";
+                    } | {
+                        readonly kind: "shell";
+                    } | {
+                        readonly command?: string | undefined;
+                        readonly kind: "action";
+                        readonly label: string;
+                    };
+                    readonly delivery: "steer" | "queue" | "attach";
+                    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 status: {
+                        readonly kind: "unsent";
+                        readonly retrying: {
+                            readonly at: number;
+                            readonly reason: string;
+                        } | null;
+                        readonly attempts: number;
+                    } | {
+                        readonly kind: "pending";
+                        readonly schedule: {
+                            readonly run: import("../../ids.ts").Id<"run">;
+                            readonly kind: "joined";
+                        } | {
+                            readonly kind: "next-turn";
+                            readonly reason: "requested" | "idle" | "run-ended" | "configuration";
+                        } | {
+                            readonly kind: "attached";
+                        } | {
+                            readonly kind: "deciding";
+                        };
+                        readonly covered: boolean;
+                    } | {
+                        readonly run: import("../../ids.ts").Id<"run"> | null;
+                        readonly commit: import("../../ids.ts").Id<"commit">;
+                        readonly kind: "landed";
+                        readonly replaced: {
+                            readonly stopped: import("../../ids.ts").Id<"run"> | null;
+                            readonly previous: import("../../ids.ts").Id<"message">;
+                        } | null;
+                    };
+                    readonly siblings: {
+                        readonly count: number;
+                        readonly index: number;
+                        readonly ids: readonly import("../../ids.ts").Id<"commit">[];
+                    };
+                } | {
+                    readonly at: number;
+                    readonly turn: import("../../ids.ts").Id<"turn">;
+                    readonly part: import("../../ids.ts").Id<"part">;
+                    readonly id: import("../../ids.ts").Id<"message">;
+                    readonly role: "answer" | "step" | "note";
+                    readonly kind: "part";
+                    readonly state: unknown;
+                    readonly partKind: string;
+                    readonly version: number;
+                    readonly status: {
+                        readonly waiting?: import("../../ids.ts").Id<"call"> | undefined;
+                        readonly answer?: {
+                            readonly input: import("../../json.ts").Json;
+                            readonly action: string;
+                        } | undefined;
+                        readonly run: import("../../ids.ts").Id<"run"> | null;
+                        readonly kind: "live";
+                    } | {
+                        readonly run: import("../../ids.ts").Id<"run">;
+                        readonly kind: "waiting";
+                        readonly on: {
+                            readonly deadline?: number | undefined;
+                            readonly session: import("../../ids.ts").Id<"session">;
+                            readonly run: import("../../ids.ts").Id<"run">;
+                            readonly kind: "run";
+                        } | {
+                            readonly deadline?: number | undefined;
+                            readonly job: import("../../ids.ts").Id<"job">;
+                            readonly kind: "job";
+                        } | {
+                            readonly deadline?: number | undefined;
+                            readonly part: import("../../ids.ts").Id<"part">;
+                            readonly kind: "part";
+                        } | {
+                            readonly deadline?: number | undefined;
+                            readonly kind: "timer";
+                            readonly until: number;
+                        };
+                    } | {
+                        readonly commit: import("../../ids.ts").Id<"commit">;
+                        readonly kind: "settled";
+                        readonly endedAt: number;
+                    } | {
+                        readonly run: import("../../ids.ts").Id<"run"> | null;
+                        readonly kind: "failed";
+                        readonly failure: {
+                            readonly retryAfterMs?: number | undefined;
+                            readonly message: string;
+                            readonly class: "provider" | "rate_limit" | "auth" | "quota" | "context_window" | "overloaded" | "network" | "aborted" | "runner";
+                        };
+                    };
+                })[];
+                readonly usage: {
+                    readonly output: number;
+                    readonly input: number;
+                    readonly cacheRead: number;
+                    readonly cacheWrite: number;
+                    readonly reasoning: number | null;
+                    readonly total: number;
+                    readonly cost: {
+                        readonly output: number;
+                        readonly input: number;
+                        readonly cacheRead: number;
+                        readonly cacheWrite: number;
+                        readonly total: number;
+                    };
+                };
+                readonly execution: {
+                    readonly kind: "idle";
+                    readonly lastRun: {
+                        readonly id: import("../../ids.ts").Id<"run">;
+                        readonly end: {
+                            readonly kind: "completed";
+                            readonly usage: {
+                                readonly output: number;
+                                readonly input: number;
+                                readonly cacheRead: number;
+                                readonly cacheWrite: number;
+                                readonly reasoning: number | null;
+                                readonly total: number;
+                                readonly cost: {
+                                    readonly output: number;
+                                    readonly input: number;
+                                    readonly cacheRead: number;
+                                    readonly cacheWrite: number;
+                                    readonly total: number;
+                                };
+                            };
+                        } | {
+                            readonly kind: "stopped";
+                        } | {
+                            readonly kind: "failed";
+                            readonly failure: {
+                                readonly retryAfterMs?: number | undefined;
+                                readonly message: string;
+                                readonly class: "provider" | "rate_limit" | "auth" | "quota" | "context_window" | "overloaded" | "network" | "aborted" | "runner";
+                            };
+                        };
+                        readonly endedAt: number;
+                    } | null;
+                } | {
+                    readonly run: {
+                        readonly head: import("../../ids.ts").Id<"head">;
+                        readonly id: import("../../ids.ts").Id<"run">;
+                        readonly configuration: {
+                            readonly kind: "exact";
+                            readonly thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                            readonly model: {
+                                readonly id: string;
+                                readonly provider: string;
+                            };
+                            readonly agent: string | null;
+                            readonly settings: {
+                                readonly [x: string]: import("../../json.ts").Json;
+                            };
+                            readonly settingsVersion: string;
+                        };
+                        readonly startedAt: number;
+                        readonly attempt: number;
+                        readonly origin: {
+                            readonly message: import("../../ids.ts").Id<"message">;
+                            readonly kind: "input";
+                        } | {
+                            readonly kind: "continuation";
+                            readonly from: "job" | "child" | "wake";
+                        };
+                    };
+                    readonly kind: "live";
+                    readonly phase: "responding" | "executing";
+                    readonly stopping: boolean;
+                } | {
+                    readonly run: {
+                        readonly head: import("../../ids.ts").Id<"head">;
+                        readonly id: import("../../ids.ts").Id<"run">;
+                        readonly configuration: {
+                            readonly kind: "exact";
+                            readonly thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                            readonly model: {
+                                readonly id: string;
+                                readonly provider: string;
+                            };
+                            readonly agent: string | null;
+                            readonly settings: {
+                                readonly [x: string]: import("../../json.ts").Json;
+                            };
+                            readonly settingsVersion: string;
+                        };
+                        readonly startedAt: number;
+                        readonly attempt: number;
+                        readonly origin: {
+                            readonly message: import("../../ids.ts").Id<"message">;
+                            readonly kind: "input";
+                        } | {
+                            readonly kind: "continuation";
+                            readonly from: "job" | "child" | "wake";
+                        };
+                    };
+                    readonly kind: "waiting";
+                    readonly on: {
+                        readonly deadline?: number | undefined;
+                        readonly session: import("../../ids.ts").Id<"session">;
+                        readonly run: import("../../ids.ts").Id<"run">;
+                        readonly kind: "run";
+                    } | {
+                        readonly deadline?: number | undefined;
+                        readonly job: import("../../ids.ts").Id<"job">;
+                        readonly kind: "job";
+                    } | {
+                        readonly deadline?: number | undefined;
+                        readonly part: import("../../ids.ts").Id<"part">;
+                        readonly kind: "part";
+                    } | {
+                        readonly deadline?: number | undefined;
+                        readonly kind: "timer";
+                        readonly until: number;
+                    };
+                } | {
+                    readonly run: {
+                        readonly head: import("../../ids.ts").Id<"head">;
+                        readonly id: import("../../ids.ts").Id<"run">;
+                        readonly configuration: {
+                            readonly kind: "exact";
+                            readonly thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                            readonly model: {
+                                readonly id: string;
+                                readonly provider: string;
+                            };
+                            readonly agent: string | null;
+                            readonly settings: {
+                                readonly [x: string]: import("../../json.ts").Json;
+                            };
+                            readonly settingsVersion: string;
+                        };
+                        readonly startedAt: number;
+                        readonly attempt: number;
+                        readonly origin: {
+                            readonly message: import("../../ids.ts").Id<"message">;
+                            readonly kind: "input";
+                        } | {
+                            readonly kind: "continuation";
+                            readonly from: "job" | "child" | "wake";
+                        };
+                    };
+                    readonly kind: "retrying";
+                    readonly reason: string;
+                    readonly until: number;
+                };
+                readonly activation: {
+                    readonly kind: "active";
+                } | {
+                    readonly kind: "inactive";
+                } | {
+                    readonly workspace: import("../../ids.ts").Id<"workspace">;
+                    readonly kind: "unavailable";
+                    readonly reason: "unreachable" | "unsupported";
+                } | {
+                    readonly message: string;
+                    readonly kind: "failed";
+                };
+                readonly catalog: {
+                    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 skills: readonly {
+                        readonly description: string;
+                        readonly name: string;
+                        readonly location: string;
+                        readonly owner: string;
+                    }[];
+                    readonly commands: readonly {
+                        readonly category?: string | undefined;
+                        readonly keywords?: readonly string[] | undefined;
+                        readonly description: string;
+                        readonly name: string;
+                        readonly title: string;
+                        readonly side: "core" | "client";
+                        readonly owner: string;
+                        readonly takesText: boolean;
+                        readonly completes: boolean;
+                    }[];
+                    readonly agents: readonly {
+                        readonly description: string | null;
+                        readonly id: string;
+                        readonly model: {
+                            readonly id: string;
+                            readonly provider: string;
+                        } | null;
+                        readonly owner: string;
+                        readonly mode: "all" | "primary" | "subagent";
+                    }[];
+                    readonly tools: readonly {
+                        readonly description: string;
+                        readonly output: {
+                            readonly [x: string]: import("../../json.ts").Json;
+                        } | null;
+                        readonly name: string;
+                        readonly owner: string;
+                        readonly namespace: string | null;
+                        readonly parameters: {
+                            readonly [x: string]: import("../../json.ts").Json;
+                        };
+                        readonly exposure: "model" | "code" | "deferred" | "hidden";
+                    }[];
+                };
+                readonly parts: readonly {
+                    readonly id: import("../../ids.ts").Id<"part">;
+                    readonly state: import("../../json.ts").Json;
+                    readonly partKind: string;
+                    readonly owner: string | null;
+                    readonly version: number;
+                    readonly status: {
+                        readonly waiting?: import("../../ids.ts").Id<"call"> | undefined;
+                        readonly answer?: {
+                            readonly input: import("../../json.ts").Json;
+                            readonly action: string;
+                        } | undefined;
+                        readonly run: import("../../ids.ts").Id<"run"> | null;
+                        readonly kind: "live";
+                    } | {
+                        readonly run: import("../../ids.ts").Id<"run">;
+                        readonly kind: "waiting";
+                        readonly on: {
+                            readonly deadline?: number | undefined;
+                            readonly session: import("../../ids.ts").Id<"session">;
+                            readonly run: import("../../ids.ts").Id<"run">;
+                            readonly kind: "run";
+                        } | {
+                            readonly deadline?: number | undefined;
+                            readonly job: import("../../ids.ts").Id<"job">;
+                            readonly kind: "job";
+                        } | {
+                            readonly deadline?: number | undefined;
+                            readonly part: import("../../ids.ts").Id<"part">;
+                            readonly kind: "part";
+                        } | {
+                            readonly deadline?: number | undefined;
+                            readonly kind: "timer";
+                            readonly until: number;
+                        };
+                    } | {
+                        readonly commit: import("../../ids.ts").Id<"commit">;
+                        readonly kind: "settled";
+                        readonly endedAt: number;
+                    } | {
+                        readonly run: import("../../ids.ts").Id<"run"> | null;
+                        readonly kind: "failed";
+                        readonly failure: {
+                            readonly retryAfterMs?: number | undefined;
+                            readonly message: string;
+                            readonly class: "provider" | "rate_limit" | "auth" | "quota" | "context_window" | "overloaded" | "network" | "aborted" | "runner";
+                        };
+                    };
+                    readonly placement: {
+                        readonly role: "answer" | "step" | "note";
+                        readonly kind: "transcript";
+                    } | {
+                        readonly kind: "modal";
+                    } | {
+                        readonly [x: string]: import("../../json.ts").Json;
+                        readonly kind: string;
+                    };
+                }[];
+                readonly changes: readonly {
+                    readonly from?: string | undefined;
+                    readonly path: string;
+                    readonly removed: number;
+                    readonly added: number;
+                    readonly status: "added" | "modified" | "deleted" | "renamed" | "untracked" | "conflicted";
+                }[];
+                readonly background: readonly {
+                    readonly id: string;
+                    readonly title: string;
+                    readonly kind: "job" | "page" | "child";
+                    readonly state: "failed" | "waiting" | "working" | "done";
+                    readonly startedBy: import("../../ids.ts").Id<"call"> | null;
+                }[];
+                readonly context: {
+                    readonly tokens: number;
+                    readonly window: number;
+                    readonly lastRequest: {
+                        readonly output: number;
+                        readonly input: number;
+                        readonly cacheRead: number;
+                        readonly cacheWrite: number;
+                        readonly reasoning: number | null;
+                        readonly total: number;
+                        readonly cost: {
+                            readonly output: number;
+                            readonly input: number;
+                            readonly cacheRead: number;
+                            readonly cacheWrite: number;
+                            readonly total: number;
+                        };
+                    } | null;
+                };
+                readonly turns: readonly {
+                    readonly run: import("../../ids.ts").Id<"run"> | null;
+                    readonly id: import("../../ids.ts").Id<"turn">;
+                    readonly state: {
+                        readonly kind: "working";
+                        readonly activity: string | null;
+                    } | {
+                        readonly kind: "waiting";
+                        readonly on: {
+                            readonly deadline?: number | undefined;
+                            readonly session: import("../../ids.ts").Id<"session">;
+                            readonly run: import("../../ids.ts").Id<"run">;
+                            readonly kind: "run";
+                        } | {
+                            readonly deadline?: number | undefined;
+                            readonly job: import("../../ids.ts").Id<"job">;
+                            readonly kind: "job";
+                        } | {
+                            readonly deadline?: number | undefined;
+                            readonly part: import("../../ids.ts").Id<"part">;
+                            readonly kind: "part";
+                        } | {
+                            readonly deadline?: number | undefined;
+                            readonly kind: "timer";
+                            readonly until: number;
+                        };
+                    } | {
+                        readonly kind: "ended";
+                        readonly end: {
+                            readonly kind: "completed";
+                            readonly usage: {
+                                readonly output: number;
+                                readonly input: number;
+                                readonly cacheRead: number;
+                                readonly cacheWrite: number;
+                                readonly reasoning: number | null;
+                                readonly total: number;
+                                readonly cost: {
+                                    readonly output: number;
+                                    readonly input: number;
+                                    readonly cacheRead: number;
+                                    readonly cacheWrite: number;
+                                    readonly total: number;
+                                };
+                            };
+                        } | {
+                            readonly kind: "stopped";
+                        } | {
+                            readonly kind: "failed";
+                            readonly failure: {
+                                readonly retryAfterMs?: number | undefined;
+                                readonly message: string;
+                                readonly class: "provider" | "rate_limit" | "auth" | "quota" | "context_window" | "overloaded" | "network" | "aborted" | "runner";
+                            };
+                        };
+                    };
+                    readonly summary: {
+                        readonly failed: number;
+                        readonly stopped: number;
+                        readonly removed: number;
+                        readonly added: number;
+                        readonly byClass: {
+                            readonly shell: {
+                                readonly paths: readonly string[];
+                                readonly count: number;
+                            };
+                            readonly edit: {
+                                readonly paths: readonly string[];
+                                readonly count: number;
+                            };
+                            readonly custom: {
+                                readonly paths: readonly string[];
+                                readonly count: number;
+                            };
+                            readonly read: {
+                                readonly paths: readonly string[];
+                                readonly count: number;
+                            };
+                            readonly list: {
+                                readonly paths: readonly string[];
+                                readonly count: number;
+                            };
+                            readonly delegate: {
+                                readonly paths: readonly string[];
+                                readonly count: number;
+                            };
+                        };
+                    };
+                    readonly startedAt: number;
+                    readonly endedAt: number | null;
+                    readonly prompt: import("../../ids.ts").Id<"message"> | null;
+                    readonly steps: number;
+                    readonly thinkingOnly: boolean;
+                }[];
+            };
+        } | {
+            readonly revision?: import("../../ids.ts").Id<"revision"> | null | undefined;
+            readonly configuration?: {
+                readonly selected: {
+                    readonly kind: "exact";
+                    readonly thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                    readonly model: {
+                        readonly id: string;
+                        readonly provider: string;
+                    };
+                    readonly agent: string | null;
+                    readonly settings: {
+                        readonly [x: string]: import("../../json.ts").Json;
+                    };
+                    readonly settingsVersion: string;
+                } | null;
+                readonly effective: {
+                    readonly kind: "exact";
+                    readonly thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                    readonly model: {
+                        readonly id: string;
+                        readonly provider: string;
+                    };
+                    readonly agent: string | null;
+                    readonly settings: {
+                        readonly [x: string]: import("../../json.ts").Json;
+                    };
+                    readonly settingsVersion: string;
+                } | null;
+            } | undefined;
+            readonly heads?: {
+                readonly items: readonly {
+                    readonly name: import("../../ids.ts").Id<"head">;
+                    readonly tip: {
+                        readonly kind: "start";
+                    } | {
+                        readonly id: import("../../ids.ts").Id<"commit">;
+                        readonly kind: "commit";
+                    };
+                    readonly stack: {
+                        readonly stale: boolean;
+                        readonly parent: import("../../ids.ts").Id<"head">;
+                        readonly base: {
+                            readonly kind: "start";
+                        } | {
+                            readonly id: import("../../ids.ts").Id<"commit">;
+                            readonly kind: "commit";
+                        };
+                    } | null;
+                    readonly execution: {
+                        readonly kind: "idle";
+                        readonly lastRun: {
+                            readonly id: import("../../ids.ts").Id<"run">;
+                            readonly end: {
+                                readonly kind: "completed";
+                                readonly usage: {
+                                    readonly output: number;
+                                    readonly input: number;
+                                    readonly cacheRead: number;
+                                    readonly cacheWrite: number;
+                                    readonly reasoning: number | null;
+                                    readonly total: number;
+                                    readonly cost: {
+                                        readonly output: number;
+                                        readonly input: number;
+                                        readonly cacheRead: number;
+                                        readonly cacheWrite: number;
+                                        readonly total: number;
+                                    };
+                                };
+                            } | {
+                                readonly kind: "stopped";
+                            } | {
+                                readonly kind: "failed";
+                                readonly failure: {
+                                    readonly retryAfterMs?: number | undefined;
+                                    readonly message: string;
+                                    readonly class: "provider" | "rate_limit" | "auth" | "quota" | "context_window" | "overloaded" | "network" | "aborted" | "runner";
+                                };
+                            };
+                            readonly endedAt: number;
+                        } | null;
+                    } | {
+                        readonly run: {
+                            readonly head: import("../../ids.ts").Id<"head">;
+                            readonly id: import("../../ids.ts").Id<"run">;
+                            readonly configuration: {
+                                readonly kind: "exact";
+                                readonly thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                                readonly model: {
+                                    readonly id: string;
+                                    readonly provider: string;
+                                };
+                                readonly agent: string | null;
+                                readonly settings: {
+                                    readonly [x: string]: import("../../json.ts").Json;
+                                };
+                                readonly settingsVersion: string;
+                            };
+                            readonly startedAt: number;
+                            readonly attempt: number;
+                            readonly origin: {
+                                readonly message: import("../../ids.ts").Id<"message">;
+                                readonly kind: "input";
+                            } | {
+                                readonly kind: "continuation";
+                                readonly from: "job" | "child" | "wake";
+                            };
+                        };
+                        readonly kind: "live";
+                        readonly phase: "responding" | "executing";
+                        readonly stopping: boolean;
+                    } | {
+                        readonly run: {
+                            readonly head: import("../../ids.ts").Id<"head">;
+                            readonly id: import("../../ids.ts").Id<"run">;
+                            readonly configuration: {
+                                readonly kind: "exact";
+                                readonly thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                                readonly model: {
+                                    readonly id: string;
+                                    readonly provider: string;
+                                };
+                                readonly agent: string | null;
+                                readonly settings: {
+                                    readonly [x: string]: import("../../json.ts").Json;
+                                };
+                                readonly settingsVersion: string;
+                            };
+                            readonly startedAt: number;
+                            readonly attempt: number;
+                            readonly origin: {
+                                readonly message: import("../../ids.ts").Id<"message">;
+                                readonly kind: "input";
+                            } | {
+                                readonly kind: "continuation";
+                                readonly from: "job" | "child" | "wake";
+                            };
+                        };
+                        readonly kind: "waiting";
+                        readonly on: {
+                            readonly deadline?: number | undefined;
+                            readonly session: import("../../ids.ts").Id<"session">;
+                            readonly run: import("../../ids.ts").Id<"run">;
+                            readonly kind: "run";
+                        } | {
+                            readonly deadline?: number | undefined;
+                            readonly job: import("../../ids.ts").Id<"job">;
+                            readonly kind: "job";
+                        } | {
+                            readonly deadline?: number | undefined;
+                            readonly part: import("../../ids.ts").Id<"part">;
+                            readonly kind: "part";
+                        } | {
+                            readonly deadline?: number | undefined;
+                            readonly kind: "timer";
+                            readonly until: number;
+                        };
+                    } | {
+                        readonly run: {
+                            readonly head: import("../../ids.ts").Id<"head">;
+                            readonly id: import("../../ids.ts").Id<"run">;
+                            readonly configuration: {
+                                readonly kind: "exact";
+                                readonly thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                                readonly model: {
+                                    readonly id: string;
+                                    readonly provider: string;
+                                };
+                                readonly agent: string | null;
+                                readonly settings: {
+                                    readonly [x: string]: import("../../json.ts").Json;
+                                };
+                                readonly settingsVersion: string;
+                            };
+                            readonly startedAt: number;
+                            readonly attempt: number;
+                            readonly origin: {
+                                readonly message: import("../../ids.ts").Id<"message">;
+                                readonly kind: "input";
+                            } | {
+                                readonly kind: "continuation";
+                                readonly from: "job" | "child" | "wake";
+                            };
+                        };
+                        readonly kind: "retrying";
+                        readonly reason: string;
+                        readonly until: number;
+                    };
+                    readonly unread: boolean;
+                }[];
+                readonly runs: readonly number[];
+            } | undefined;
+            readonly messages?: {
+                readonly items: readonly ({
+                    readonly at: number;
+                    readonly turn: import("../../ids.ts").Id<"turn">;
+                    readonly id: import("../../ids.ts").Id<"message">;
+                    readonly kind: "user";
+                    readonly source: {
+                        readonly kind: "user";
+                    } | {
+                        readonly session: import("../../ids.ts").Id<"session">;
+                        readonly kind: "child";
+                        readonly end: "failed" | "completed" | "stopped";
+                    } | {
+                        readonly job: import("../../ids.ts").Id<"job">;
+                        readonly kind: "job";
+                    } | {
+                        readonly kind: "shell";
+                    } | {
+                        readonly command?: string | undefined;
+                        readonly kind: "action";
+                        readonly label: string;
+                    };
+                    readonly delivery: "steer" | "queue" | "attach";
+                    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 status: {
+                        readonly kind: "unsent";
+                        readonly retrying: {
+                            readonly at: number;
+                            readonly reason: string;
+                        } | null;
+                        readonly attempts: number;
+                    } | {
+                        readonly kind: "pending";
+                        readonly schedule: {
+                            readonly run: import("../../ids.ts").Id<"run">;
+                            readonly kind: "joined";
+                        } | {
+                            readonly kind: "next-turn";
+                            readonly reason: "requested" | "idle" | "run-ended" | "configuration";
+                        } | {
+                            readonly kind: "attached";
+                        } | {
+                            readonly kind: "deciding";
+                        };
+                        readonly covered: boolean;
+                    } | {
+                        readonly run: import("../../ids.ts").Id<"run"> | null;
+                        readonly commit: import("../../ids.ts").Id<"commit">;
+                        readonly kind: "landed";
+                        readonly replaced: {
+                            readonly stopped: import("../../ids.ts").Id<"run"> | null;
+                            readonly previous: import("../../ids.ts").Id<"message">;
+                        } | null;
+                    };
+                    readonly siblings: {
+                        readonly count: number;
+                        readonly index: number;
+                        readonly ids: readonly import("../../ids.ts").Id<"commit">[];
+                    };
+                } | {
+                    readonly at: number;
+                    readonly turn: import("../../ids.ts").Id<"turn">;
+                    readonly part: import("../../ids.ts").Id<"part">;
+                    readonly id: import("../../ids.ts").Id<"message">;
+                    readonly role: "answer" | "step" | "note";
+                    readonly kind: "part";
+                    readonly state: unknown;
+                    readonly partKind: string;
+                    readonly version: number;
+                    readonly status: {
+                        readonly waiting?: import("../../ids.ts").Id<"call"> | undefined;
+                        readonly answer?: {
+                            readonly input: import("../../json.ts").Json;
+                            readonly action: string;
+                        } | undefined;
+                        readonly run: import("../../ids.ts").Id<"run"> | null;
+                        readonly kind: "live";
+                    } | {
+                        readonly run: import("../../ids.ts").Id<"run">;
+                        readonly kind: "waiting";
+                        readonly on: {
+                            readonly deadline?: number | undefined;
+                            readonly session: import("../../ids.ts").Id<"session">;
+                            readonly run: import("../../ids.ts").Id<"run">;
+                            readonly kind: "run";
+                        } | {
+                            readonly deadline?: number | undefined;
+                            readonly job: import("../../ids.ts").Id<"job">;
+                            readonly kind: "job";
+                        } | {
+                            readonly deadline?: number | undefined;
+                            readonly part: import("../../ids.ts").Id<"part">;
+                            readonly kind: "part";
+                        } | {
+                            readonly deadline?: number | undefined;
+                            readonly kind: "timer";
+                            readonly until: number;
+                        };
+                    } | {
+                        readonly commit: import("../../ids.ts").Id<"commit">;
+                        readonly kind: "settled";
+                        readonly endedAt: number;
+                    } | {
+                        readonly run: import("../../ids.ts").Id<"run"> | null;
+                        readonly kind: "failed";
+                        readonly failure: {
+                            readonly retryAfterMs?: number | undefined;
+                            readonly message: string;
+                            readonly class: "provider" | "rate_limit" | "auth" | "quota" | "context_window" | "overloaded" | "network" | "aborted" | "runner";
+                        };
+                    };
+                })[];
+                readonly runs: readonly number[];
+            } | undefined;
+            readonly usage?: {
+                readonly output: number;
+                readonly input: number;
+                readonly cacheRead: number;
+                readonly cacheWrite: number;
+                readonly reasoning: number | null;
+                readonly total: number;
+                readonly cost: {
+                    readonly output: number;
+                    readonly input: number;
+                    readonly cacheRead: number;
+                    readonly cacheWrite: number;
+                    readonly total: number;
+                };
+            } | undefined;
+            readonly execution?: {
+                readonly kind: "idle";
+                readonly lastRun: {
+                    readonly id: import("../../ids.ts").Id<"run">;
+                    readonly end: {
+                        readonly kind: "completed";
+                        readonly usage: {
+                            readonly output: number;
+                            readonly input: number;
+                            readonly cacheRead: number;
+                            readonly cacheWrite: number;
+                            readonly reasoning: number | null;
+                            readonly total: number;
+                            readonly cost: {
+                                readonly output: number;
+                                readonly input: number;
+                                readonly cacheRead: number;
+                                readonly cacheWrite: number;
+                                readonly total: number;
+                            };
+                        };
+                    } | {
+                        readonly kind: "stopped";
+                    } | {
+                        readonly kind: "failed";
+                        readonly failure: {
+                            readonly retryAfterMs?: number | undefined;
+                            readonly message: string;
+                            readonly class: "provider" | "rate_limit" | "auth" | "quota" | "context_window" | "overloaded" | "network" | "aborted" | "runner";
+                        };
+                    };
+                    readonly endedAt: number;
+                } | null;
+            } | {
+                readonly run: {
+                    readonly head: import("../../ids.ts").Id<"head">;
+                    readonly id: import("../../ids.ts").Id<"run">;
+                    readonly configuration: {
+                        readonly kind: "exact";
+                        readonly thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                        readonly model: {
+                            readonly id: string;
+                            readonly provider: string;
+                        };
+                        readonly agent: string | null;
+                        readonly settings: {
+                            readonly [x: string]: import("../../json.ts").Json;
+                        };
+                        readonly settingsVersion: string;
+                    };
+                    readonly startedAt: number;
+                    readonly attempt: number;
+                    readonly origin: {
+                        readonly message: import("../../ids.ts").Id<"message">;
+                        readonly kind: "input";
+                    } | {
+                        readonly kind: "continuation";
+                        readonly from: "job" | "child" | "wake";
+                    };
+                };
+                readonly kind: "live";
+                readonly phase: "responding" | "executing";
+                readonly stopping: boolean;
+            } | {
+                readonly run: {
+                    readonly head: import("../../ids.ts").Id<"head">;
+                    readonly id: import("../../ids.ts").Id<"run">;
+                    readonly configuration: {
+                        readonly kind: "exact";
+                        readonly thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                        readonly model: {
+                            readonly id: string;
+                            readonly provider: string;
+                        };
+                        readonly agent: string | null;
+                        readonly settings: {
+                            readonly [x: string]: import("../../json.ts").Json;
+                        };
+                        readonly settingsVersion: string;
+                    };
+                    readonly startedAt: number;
+                    readonly attempt: number;
+                    readonly origin: {
+                        readonly message: import("../../ids.ts").Id<"message">;
+                        readonly kind: "input";
+                    } | {
+                        readonly kind: "continuation";
+                        readonly from: "job" | "child" | "wake";
+                    };
+                };
+                readonly kind: "waiting";
+                readonly on: {
+                    readonly deadline?: number | undefined;
+                    readonly session: import("../../ids.ts").Id<"session">;
+                    readonly run: import("../../ids.ts").Id<"run">;
+                    readonly kind: "run";
+                } | {
+                    readonly deadline?: number | undefined;
+                    readonly job: import("../../ids.ts").Id<"job">;
+                    readonly kind: "job";
+                } | {
+                    readonly deadline?: number | undefined;
+                    readonly part: import("../../ids.ts").Id<"part">;
+                    readonly kind: "part";
+                } | {
+                    readonly deadline?: number | undefined;
+                    readonly kind: "timer";
+                    readonly until: number;
+                };
+            } | {
+                readonly run: {
+                    readonly head: import("../../ids.ts").Id<"head">;
+                    readonly id: import("../../ids.ts").Id<"run">;
+                    readonly configuration: {
+                        readonly kind: "exact";
+                        readonly thinking: "off" | "minimal" | "low" | "medium" | "high" | "xhigh" | "max";
+                        readonly model: {
+                            readonly id: string;
+                            readonly provider: string;
+                        };
+                        readonly agent: string | null;
+                        readonly settings: {
+                            readonly [x: string]: import("../../json.ts").Json;
+                        };
+                        readonly settingsVersion: string;
+                    };
+                    readonly startedAt: number;
+                    readonly attempt: number;
+                    readonly origin: {
+                        readonly message: import("../../ids.ts").Id<"message">;
+                        readonly kind: "input";
+                    } | {
+                        readonly kind: "continuation";
+                        readonly from: "job" | "child" | "wake";
+                    };
+                };
+                readonly kind: "retrying";
+                readonly reason: string;
+                readonly until: number;
+            } | undefined;
+            readonly activation?: {
+                readonly kind: "active";
+            } | {
+                readonly kind: "inactive";
+            } | {
+                readonly workspace: import("../../ids.ts").Id<"workspace">;
+                readonly kind: "unavailable";
+                readonly reason: "unreachable" | "unsupported";
+            } | {
+                readonly message: string;
+                readonly kind: "failed";
+            } | undefined;
+            readonly catalog?: {
+                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 skills: readonly {
+                    readonly description: string;
+                    readonly name: string;
+                    readonly location: string;
+                    readonly owner: string;
+                }[];
+                readonly commands: readonly {
+                    readonly category?: string | undefined;
+                    readonly keywords?: readonly string[] | undefined;
+                    readonly description: string;
+                    readonly name: string;
+                    readonly title: string;
+                    readonly side: "core" | "client";
+                    readonly owner: string;
+                    readonly takesText: boolean;
+                    readonly completes: boolean;
+                }[];
+                readonly agents: readonly {
+                    readonly description: string | null;
+                    readonly id: string;
+                    readonly model: {
+                        readonly id: string;
+                        readonly provider: string;
+                    } | null;
+                    readonly owner: string;
+                    readonly mode: "all" | "primary" | "subagent";
+                }[];
+                readonly tools: readonly {
+                    readonly description: string;
+                    readonly output: {
+                        readonly [x: string]: import("../../json.ts").Json;
+                    } | null;
+                    readonly name: string;
+                    readonly owner: string;
+                    readonly namespace: string | null;
+                    readonly parameters: {
+                        readonly [x: string]: import("../../json.ts").Json;
+                    };
+                    readonly exposure: "model" | "code" | "deferred" | "hidden";
+                }[];
+            } | undefined;
+            readonly parts?: {
+                readonly items: readonly {
+                    readonly id: import("../../ids.ts").Id<"part">;
+                    readonly state: import("../../json.ts").Json;
+                    readonly partKind: string;
+                    readonly owner: string | null;
+                    readonly version: number;
+                    readonly status: {
+                        readonly waiting?: import("../../ids.ts").Id<"call"> | undefined;
+                        readonly answer?: {
+                            readonly input: import("../../json.ts").Json;
+                            readonly action: string;
+                        } | undefined;
+                        readonly run: import("../../ids.ts").Id<"run"> | null;
+                        readonly kind: "live";
+                    } | {
+                        readonly run: import("../../ids.ts").Id<"run">;
+                        readonly kind: "waiting";
+                        readonly on: {
+                            readonly deadline?: number | undefined;
+                            readonly session: import("../../ids.ts").Id<"session">;
+                            readonly run: import("../../ids.ts").Id<"run">;
+                            readonly kind: "run";
+                        } | {
+                            readonly deadline?: number | undefined;
+                            readonly job: import("../../ids.ts").Id<"job">;
+                            readonly kind: "job";
+                        } | {
+                            readonly deadline?: number | undefined;
+                            readonly part: import("../../ids.ts").Id<"part">;
+                            readonly kind: "part";
+                        } | {
+                            readonly deadline?: number | undefined;
+                            readonly kind: "timer";
+                            readonly until: number;
+                        };
+                    } | {
+                        readonly commit: import("../../ids.ts").Id<"commit">;
+                        readonly kind: "settled";
+                        readonly endedAt: number;
+                    } | {
+                        readonly run: import("../../ids.ts").Id<"run"> | null;
+                        readonly kind: "failed";
+                        readonly failure: {
+                            readonly retryAfterMs?: number | undefined;
+                            readonly message: string;
+                            readonly class: "provider" | "rate_limit" | "auth" | "quota" | "context_window" | "overloaded" | "network" | "aborted" | "runner";
+                        };
+                    };
+                    readonly placement: {
+                        readonly role: "answer" | "step" | "note";
+                        readonly kind: "transcript";
+                    } | {
+                        readonly kind: "modal";
+                    } | {
+                        readonly [x: string]: import("../../json.ts").Json;
+                        readonly kind: string;
+                    };
+                }[];
+                readonly runs: readonly number[];
+            } | undefined;
+            readonly changes?: {
+                readonly items: readonly {
+                    readonly from?: string | undefined;
+                    readonly path: string;
+                    readonly removed: number;
+                    readonly added: number;
+                    readonly status: "added" | "modified" | "deleted" | "renamed" | "untracked" | "conflicted";
+                }[];
+                readonly runs: readonly number[];
+            } | undefined;
+            readonly background?: {
+                readonly items: readonly {
+                    readonly id: string;
+                    readonly title: string;
+                    readonly kind: "job" | "page" | "child";
+                    readonly state: "failed" | "waiting" | "working" | "done";
+                    readonly startedBy: import("../../ids.ts").Id<"call"> | null;
+                }[];
+                readonly runs: readonly number[];
+            } | undefined;
+            readonly context?: {
+                readonly tokens: number;
+                readonly window: number;
+                readonly lastRequest: {
+                    readonly output: number;
+                    readonly input: number;
+                    readonly cacheRead: number;
+                    readonly cacheWrite: number;
+                    readonly reasoning: number | null;
+                    readonly total: number;
+                    readonly cost: {
+                        readonly output: number;
+                        readonly input: number;
+                        readonly cacheRead: number;
+                        readonly cacheWrite: number;
+                        readonly total: number;
+                    };
+                } | null;
+            } | undefined;
+            readonly turns?: {
+                readonly items: readonly {
+                    readonly run: import("../../ids.ts").Id<"run"> | null;
+                    readonly id: import("../../ids.ts").Id<"turn">;
+                    readonly state: {
+                        readonly kind: "working";
+                        readonly activity: string | null;
+                    } | {
+                        readonly kind: "waiting";
+                        readonly on: {
+                            readonly deadline?: number | undefined;
+                            readonly session: import("../../ids.ts").Id<"session">;
+                            readonly run: import("../../ids.ts").Id<"run">;
+                            readonly kind: "run";
+                        } | {
+                            readonly deadline?: number | undefined;
+                            readonly job: import("../../ids.ts").Id<"job">;
+                            readonly kind: "job";
+                        } | {
+                            readonly deadline?: number | undefined;
+                            readonly part: import("../../ids.ts").Id<"part">;
+                            readonly kind: "part";
+                        } | {
+                            readonly deadline?: number | undefined;
+                            readonly kind: "timer";
+                            readonly until: number;
+                        };
+                    } | {
+                        readonly kind: "ended";
+                        readonly end: {
+                            readonly kind: "completed";
+                            readonly usage: {
+                                readonly output: number;
+                                readonly input: number;
+                                readonly cacheRead: number;
+                                readonly cacheWrite: number;
+                                readonly reasoning: number | null;
+                                readonly total: number;
+                                readonly cost: {
+                                    readonly output: number;
+                                    readonly input: number;
+                                    readonly cacheRead: number;
+                                    readonly cacheWrite: number;
+                                    readonly total: number;
+                                };
+                            };
+                        } | {
+                            readonly kind: "stopped";
+                        } | {
+                            readonly kind: "failed";
+                            readonly failure: {
+                                readonly retryAfterMs?: number | undefined;
+                                readonly message: string;
+                                readonly class: "provider" | "rate_limit" | "auth" | "quota" | "context_window" | "overloaded" | "network" | "aborted" | "runner";
+                            };
+                        };
+                    };
+                    readonly summary: {
+                        readonly failed: number;
+                        readonly stopped: number;
+                        readonly removed: number;
+                        readonly added: number;
+                        readonly byClass: {
+                            readonly shell: {
+                                readonly paths: readonly string[];
+                                readonly count: number;
+                            };
+                            readonly edit: {
+                                readonly paths: readonly string[];
+                                readonly count: number;
+                            };
+                            readonly custom: {
+                                readonly paths: readonly string[];
+                                readonly count: number;
+                            };
+                            readonly read: {
+                                readonly paths: readonly string[];
+                                readonly count: number;
+                            };
+                            readonly list: {
+                                readonly paths: readonly string[];
+                                readonly count: number;
+                            };
+                            readonly delegate: {
+                                readonly paths: readonly string[];
+                                readonly count: number;
+                            };
+                        };
+                    };
+                    readonly startedAt: number;
+                    readonly endedAt: number | null;
+                    readonly prompt: import("../../ids.ts").Id<"message"> | null;
+                    readonly steps: number;
+                    readonly thinkingOnly: boolean;
+                }[];
+                readonly runs: readonly number[];
+            } | undefined;
+            readonly appends?: readonly {
+                readonly at: number;
+                readonly version: number;
+                readonly append: string;
+            }[] | undefined;
+            readonly seq: import("../../ids.ts").Seq;
+            readonly kind: "delta";
+        }>;
+        readonly authority: "participant";
+        readonly scope: "session";
+    };
+    readonly "head.history": {
+        readonly kind: "query";
+        readonly input: import("../../schema.ts").Schema<{
+            session: import("../../ids.ts").Id<"session">;
+            head: import("../../ids.ts").Id<"head">;
+            limit: number;
+            before: import("../../ids.ts").Id<"message">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            messages: ({
+                at: number;
+                turn: import("../../ids.ts").Id<"turn">;
+                id: import("../../ids.ts").Id<"message">;
+                kind: "user";
+                source: {
+                    kind: "user";
+                } | {
+                    session: import("../../ids.ts").Id<"session">;
+                    kind: "child";
+                    end: "failed" | "completed" | "stopped";
+                } | {
+                    job: import("../../ids.ts").Id<"job">;
+                    kind: "job";
+                } | {
+                    kind: "shell";
+                } | {
+                    command?: string | undefined;
+                    kind: "action";
+                    label: string;
+                };
+                delivery: "steer" | "queue" | "attach";
+                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;
+                    };
+                })[];
+                status: {
+                    kind: "unsent";
+                    retrying: {
+                        at: number;
+                        reason: string;
+                    } | null;
+                    attempts: number;
+                } | {
+                    kind: "pending";
+                    schedule: {
+                        run: import("../../ids.ts").Id<"run">;
+                        kind: "joined";
+                    } | {
+                        kind: "next-turn";
+                        reason: "requested" | "idle" | "run-ended" | "configuration";
+                    } | {
+                        kind: "attached";
+                    } | {
+                        kind: "deciding";
+                    };
+                    covered: boolean;
+                } | {
+                    run: import("../../ids.ts").Id<"run"> | null;
+                    commit: import("../../ids.ts").Id<"commit">;
+                    kind: "landed";
+                    replaced: {
+                        stopped: import("../../ids.ts").Id<"run"> | null;
+                        previous: import("../../ids.ts").Id<"message">;
+                    } | null;
+                };
+                siblings: {
+                    count: number;
+                    index: number;
+                    ids: import("../../ids.ts").Id<"commit">[];
+                };
+            } | {
+                at: number;
+                turn: import("../../ids.ts").Id<"turn">;
+                part: import("../../ids.ts").Id<"part">;
+                id: import("../../ids.ts").Id<"message">;
+                role: "answer" | "step" | "note";
+                kind: "part";
+                state: unknown;
+                partKind: string;
+                version: number;
+                status: {
+                    waiting?: import("../../ids.ts").Id<"call"> | undefined;
+                    answer?: {
+                        input: import("../../json.ts").Json;
+                        action: string;
+                    } | undefined;
+                    run: import("../../ids.ts").Id<"run"> | null;
+                    kind: "live";
+                } | {
+                    run: import("../../ids.ts").Id<"run">;
+                    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;
+                    };
+                } | {
+                    commit: import("../../ids.ts").Id<"commit">;
+                    kind: "settled";
+                    endedAt: number;
+                } | {
+                    run: import("../../ids.ts").Id<"run"> | null;
+                    kind: "failed";
+                    failure: {
+                        retryAfterMs?: number | undefined;
+                        message: string;
+                        class: "provider" | "rate_limit" | "auth" | "quota" | "context_window" | "overloaded" | "network" | "aborted" | "runner";
+                    };
+                };
+            })[];
+            turns: {
+                run: import("../../ids.ts").Id<"run"> | null;
+                id: import("../../ids.ts").Id<"turn">;
+                state: {
+                    kind: "working";
+                    activity: string | null;
+                } | {
+                    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;
+                    };
+                } | {
+                    kind: "ended";
+                    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";
+                        };
+                    };
+                };
+                summary: {
+                    failed: number;
+                    stopped: number;
+                    removed: number;
+                    added: number;
+                    byClass: {
+                        shell: {
+                            paths: string[];
+                            count: number;
+                        };
+                        edit: {
+                            paths: string[];
+                            count: number;
+                        };
+                        custom: {
+                            paths: string[];
+                            count: number;
+                        };
+                        read: {
+                            paths: string[];
+                            count: number;
+                        };
+                        list: {
+                            paths: string[];
+                            count: number;
+                        };
+                        delegate: {
+                            paths: string[];
+                            count: number;
+                        };
+                    };
+                };
+                startedAt: number;
+                endedAt: number | null;
+                prompt: import("../../ids.ts").Id<"message"> | null;
+                steps: number;
+                thinkingOnly: boolean;
+            }[];
+        }>;
+        readonly authority: "participant";
+        readonly scope: "session";
+    };
+    readonly "head.tree": {
+        readonly kind: "query";
+        readonly input: import("../../schema.ts").Schema<{
+            session: import("../../ids.ts").Id<"session">;
+            head: import("../../ids.ts").Id<"head">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly revision: import("../../ids.ts").Id<"revision"> | null;
+            readonly nodes: readonly {
+                readonly at: number;
+                readonly run: import("../../ids.ts").Id<"run"> | null;
+                readonly id: import("../../ids.ts").Id<"commit">;
+                readonly depth: number;
+                readonly kind: "part" | "user" | "compaction" | "branchSummary";
+                readonly active: boolean;
+                readonly parent: import("../../ids.ts").Id<"commit"> | null;
+                readonly branch: boolean;
+                readonly heads: readonly import("../../ids.ts").Id<"head">[];
+                readonly partKind: string | null;
+                readonly preview: string;
+            }[];
+            readonly tip: {
+                readonly kind: "start";
+            } | {
+                readonly id: import("../../ids.ts").Id<"commit">;
+                readonly kind: "commit";
+            };
+        }>;
+        readonly authority: "participant";
+        readonly scope: "session";
+    };
+    readonly "head.move": {
+        readonly kind: "receipt";
+        readonly recovery: "replay";
+        readonly input: import("../../schema.ts").Schema<{
+            id?: import("../../ids.ts").Id<"receipt"> | undefined;
+            options?: {
+                running?: "refuse" | "stop" | undefined;
+                abandoned?: "keep" | {
+                    summarize: {
+                        instructions?: string | undefined;
+                    };
+                } | undefined;
+                expect?: import("../../ids.ts").Id<"revision"> | undefined;
+            } | undefined;
+            session: import("../../ids.ts").Id<"session">;
+            head: import("../../ids.ts").Id<"head">;
+            position: {
+                kind: "start";
+            } | {
+                id: import("../../ids.ts").Id<"commit">;
+                kind: "commit";
+            };
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            receipt: import("../../ids.ts").Id<"receipt">;
+        }>;
+        readonly authority: "participant";
+        readonly scope: "session";
+    };
+    readonly "head.compact": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            instructions?: string | undefined;
+            session: import("../../ids.ts").Id<"session">;
+            head: import("../../ids.ts").Id<"head">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            message: import("../../ids.ts").Id<"message">;
+            kind: "started";
+        } | {
+            run: import("../../ids.ts").Id<"run">;
+            kind: "busy";
+        } | {
+            kind: "nothing-to-compact";
+        }>;
+        readonly authority: "participant";
+        readonly scope: "session";
+    };
+    readonly "heads.create": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            input?: {
+                from?: {
+                    kind: "start";
+                } | {
+                    id: import("../../ids.ts").Id<"commit">;
+                    kind: "commit";
+                } | undefined;
+            } | undefined;
+            name: import("../../ids.ts").Id<"head">;
+            session: import("../../ids.ts").Id<"session">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly kind: "created";
+            readonly basedOn: {
+                readonly kind: "start";
+            } | {
+                readonly id: import("../../ids.ts").Id<"commit">;
+                readonly kind: "commit";
+            };
+        } | {
+            readonly kind: "exists";
+        } | {
+            readonly kind: "missing-source";
+        }>;
+        readonly authority: "participant";
+        readonly scope: "session";
+    };
+    readonly "heads.merge": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            options?: {
+                expect?: import("../../ids.ts").Id<"revision"> | undefined;
+            } | undefined;
+            name: import("../../ids.ts").Id<"head">;
+            session: import("../../ids.ts").Id<"session">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly revision: import("../../ids.ts").Id<"revision">;
+            readonly kind: "merged";
+        } | {
+            readonly revision: import("../../ids.ts").Id<"revision">;
+            readonly kind: "stale";
+        } | {
+            readonly kind: "diverged";
+            readonly base: {
+                readonly kind: "start";
+            } | {
+                readonly id: import("../../ids.ts").Id<"commit">;
+                readonly kind: "commit";
+            };
+        } | {
+            readonly kind: "is-main";
+        } | {
+            readonly run: import("../../ids.ts").Id<"run">;
+            readonly kind: "busy";
+        }>;
+        readonly authority: "participant";
+        readonly scope: "session";
+    };
+    readonly "heads.remove": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            options?: {
+                expect?: import("../../ids.ts").Id<"revision"> | undefined;
+            } | undefined;
+            name: import("../../ids.ts").Id<"head">;
+            session: import("../../ids.ts").Id<"session">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly kind: "removed";
+        } | {
+            readonly kind: "missing";
+        } | {
+            readonly kind: "is-main";
+        } | {
+            readonly run: import("../../ids.ts").Id<"run">;
+            readonly kind: "busy";
+        }>;
+        readonly authority: "participant";
+        readonly scope: "session";
+    };
+    readonly "run.stop": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            session: import("../../ids.ts").Id<"session">;
+            run: import("../../ids.ts").Id<"run">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            kind: "requested";
+        } | {
+            kind: "settled";
+            outcome: {
+                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";
+                };
+            };
+        } | {
+            kind: "missing";
+        }>;
+        readonly authority: "participant";
+        readonly scope: "session";
+    };
+    readonly "run.settled": {
+        readonly kind: "query";
+        readonly wait: true;
+        readonly input: import("../../schema.ts").Schema<{
+            session: import("../../ids.ts").Id<"session">;
+            run: import("../../ids.ts").Id<"run">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            readonly kind: "completed";
+            readonly usage: {
+                readonly output: number;
+                readonly input: number;
+                readonly cacheRead: number;
+                readonly cacheWrite: number;
+                readonly reasoning: number | null;
+                readonly total: number;
+                readonly cost: {
+                    readonly output: number;
+                    readonly input: number;
+                    readonly cacheRead: number;
+                    readonly cacheWrite: number;
+                    readonly total: number;
+                };
+            };
+        } | {
+            readonly kind: "stopped";
+        } | {
+            readonly kind: "failed";
+            readonly failure: {
+                readonly retryAfterMs?: number | undefined;
+                readonly message: string;
+                readonly class: "provider" | "rate_limit" | "auth" | "quota" | "context_window" | "overloaded" | "network" | "aborted" | "runner";
+            };
+        }>;
+        readonly authority: "participant";
+        readonly scope: "session";
+    };
+    readonly "receipt.status": {
+        readonly kind: "query";
+        readonly input: import("../../schema.ts").Schema<{
+            session: import("../../ids.ts").Id<"session"> | null;
+            receipt: import("../../ids.ts").Id<"receipt">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            kind: "pending";
+        } | {
+            kind: "settled";
+            outcome: import("../../json.ts").Json;
+        } | {
+            kind: "missing";
+        }>;
+        readonly authority: "participant";
+        readonly scope: "session";
+    };
+    readonly "receipt.settled": {
+        readonly kind: "query";
+        readonly wait: true;
+        readonly input: import("../../schema.ts").Schema<{
+            session: import("../../ids.ts").Id<"session"> | null;
+            receipt: import("../../ids.ts").Id<"receipt">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<import("../../json.ts").Json>;
+        readonly authority: "participant";
+        readonly scope: "session";
+    };
+    readonly "receipt.stop": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            session: import("../../ids.ts").Id<"session"> | null;
+            receipt: import("../../ids.ts").Id<"receipt">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            kind: "requested";
+        } | {
+            kind: "settled";
+            outcome: import("../../json.ts").Json;
+        } | {
+            kind: "missing";
+        }>;
+        readonly authority: "participant";
+        readonly scope: "session";
+    };
+    readonly "receipt.landed": {
+        readonly kind: "query";
+        readonly wait: true;
+        readonly input: import("../../schema.ts").Schema<{
+            session: import("../../ids.ts").Id<"session"> | null;
+            receipt: import("../../ids.ts").Id<"receipt">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            run: import("../../ids.ts").Id<"run"> | null;
+            commit: import("../../ids.ts").Id<"commit">;
+            kind: "landed";
+            replaced: {
+                stopped: import("../../ids.ts").Id<"run"> | null;
+                previous: import("../../ids.ts").Id<"message">;
+            } | null;
+        } | {
+            kind: "withdrawn";
+        } | {
+            revision: import("../../ids.ts").Id<"revision">;
+            kind: "stale";
+        } | {
+            run: import("../../ids.ts").Id<"run">;
+            kind: "busy";
+        } | {
+            kind: "pending-input";
+            messages: import("../../ids.ts").Id<"message">[];
+        } | {
+            kind: "missing-target";
+        } | {
+            kind: "summary-failed";
+            reason: string;
+        }>;
+        readonly authority: "participant";
+        readonly scope: "session";
+    };
+    readonly "parts.create": {
+        readonly kind: "command";
+        readonly recovery: "replay";
+        readonly input: import("../../schema.ts").Schema<{
+            session: import("../../ids.ts").Id<"session">;
+            kind: string;
+            input: {
+                id?: import("../../ids.ts").Id<"part"> | undefined;
+                state: import("../../json.ts").Json;
+                placement: {
+                    role: "answer" | "step" | "note";
+                    kind: "transcript";
+                } | {
+                    kind: "modal";
+                } | ({
+                    kind: string;
+                } & Record<string, import("../../json.ts").Json>);
+            };
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            part: import("../../ids.ts").Id<"part">;
+        }>;
+        readonly authority: "participant";
+        readonly scope: "session";
+    };
+    readonly "part.update": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            options?: {
+                version?: number | undefined;
+            } | undefined;
+            session: import("../../ids.ts").Id<"session">;
+            part: import("../../ids.ts").Id<"part">;
+            next: import("../../json.ts").Json;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            kind: "updated";
+            version: number;
+        } | {
+            issues: {
+                source?: {
+                    file?: string | undefined;
+                    line?: number | undefined;
+                    plugin: string;
+                } | undefined;
+                message: string;
+                severity: "error" | "warning";
+                path: (string | number)[];
+            }[];
+            kind: "invalid";
+        } | {
+            kind: "closed";
+        } | {
+            kind: "missing";
+        } | {
+            kind: "stale";
+        }>;
+        readonly authority: "participant";
+        readonly scope: "session";
+    };
+    readonly "part.act": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            session: import("../../ids.ts").Id<"session">;
+            part: import("../../ids.ts").Id<"part">;
+            input: import("../../json.ts").Json;
+            action: string;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            output: import("../../json.ts").Json;
+            kind: "ok";
+        } | {
+            kind: "rejected";
+            reason: string;
+        } | {
+            kind: "unknown-action";
+        } | {
+            kind: "closed";
+        } | {
+            kind: "no-owner";
+        } | {
+            message: string;
+            kind: "failed";
+        }>;
+        readonly authority: "participant";
+        readonly scope: "session";
+    };
+    readonly "part.answer": {
+        readonly kind: "query";
+        readonly wait: true;
+        readonly input: import("../../schema.ts").Schema<{
+            session: import("../../ids.ts").Id<"session">;
+            part: import("../../ids.ts").Id<"part">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<{
+            input: import("../../json.ts").Json;
+            action: string;
+        } | null>;
+        readonly authority: "participant";
+        readonly scope: "session";
+    };
+    readonly "part.close": {
+        readonly kind: "command";
+        readonly input: import("../../schema.ts").Schema<{
+            session: import("../../ids.ts").Id<"session">;
+            part: import("../../ids.ts").Id<"part">;
+        }>;
+        readonly output: import("../../schema.ts").Schema<null>;
+        readonly authority: "participant";
+        readonly scope: "session";
+    };
+};