@joe-broadhead/messaging 0.0.0-stage → 0.7.1

package/dist/types/core/schema/ipc.d.ts

@@ -0,0 +1,3146 @@
+/**
+ * Local daemon API. JSON-RPC 2.0, one JSON object per line (NDJSON), over two Unix sockets in
+ * `$MESSAGING_HOME/run/` (spec §8.2, "Two sockets"), each 0600 (the agent socket 0660 to
+ * `ipc.agentGroup` when set):
+ *
+ * - `run/agent.sock` serves only `AGENT_METHODS` (the agent tier): the session, contacts, send,
+ *   inbox, item, conversation, search, task and events methods. The daemon refuses anything else with
+ *   `forbidden`. Agent-facing clients (OpenCode plugin tools, MCP server) connect here.
+ * - `run/admin.sock` serves every method: the agent tier, `HUMAN_METHODS` (acting as the person:
+ *   conversations, the person's own lines, people, channels) and `ADMIN_METHODS` (this device and the
+ *   team). Human clients (the `messaging` CLI and the `/messaging` TUI) connect here; agent-facing
+ *   clients never expose these methods.
+ *
+ * Params are strict: a key a method does not define is refused (-32602), never dropped.
+ *
+ * Errors: standard JSON-RPC codes for transport/schema problems (-32700, -32600, -32601, -32602,
+ * -32603); every Messaging error uses code -32000 with `data: { code: ErrorCode }`.
+ * The daemon pushes notifications `{"jsonrpc":"2.0","method":"event","params":Event}`: `conv` events
+ * to connections that called `conv.subscribe`, every other event to connections that called
+ * `events.subscribe` for its key (or to all of them, for events without a key).
+ */
+import { z } from "zod";
+export * from "./ipc/shapes.js";
+export * from "./ipc/surfaces.js";
+export * from "./ipc/jelly.js";
+export declare const MESSAGING_ERROR_RPC_CODE = -32000;
+/**
+ * Where the daemon can reach a session's host to wake it while no connection holds the session's
+ * key (spec §8.6). Local only: the daemon never publishes it.
+ *
+ * `opencode`: the OpenCode session `sessionID` lives in the location (directory) `location` of the
+ * OpenCode server process `pid`. `location` is absolute: a POSIX path (`/…`), or a Windows drive path
+ * (`C:\…` or `C:/…`) below the drive's root. The daemon may call that server's `messaging.opencode/wake` RPC at
+ * `location`, and nothing else, while OpenCode's service registration names the same `pid`.
+ */
+export declare const SessionHost: z.ZodObject<{
+    kind: z.ZodLiteral<"opencode">;
+    location: z.ZodString;
+    sessionID: z.ZodString;
+    pid: z.ZodNumber;
+}, z.core.$strict>;
+export type SessionHost = z.infer<typeof SessionHost>;
+/**
+ * The local API's protocol number. A client and a daemon must speak the same one, and be the same
+ * release (`VERSION`): there is no compatibility across versions (spec §8.2).
+ */
+export declare const IPC_PROTOCOL = 1;
+/**
+ * The daemon's first line on every connection, before any request: a JSON-RPC notification
+ * `{"jsonrpc":"2.0","method":"hello","params":IpcHello}` (spec §8.2). A client reads it before it
+ * sends anything, and refuses a daemon of another `version` or `protocol` with `daemon_mismatch`.
+ * Every release keeps this shape, so any client can say which daemon it found and `messaging daemon
+ * stop` can stop it by `pid`. Unknown fields are ignored.
+ */
+export declare const IpcHello: z.ZodObject<{
+    daemon: z.ZodLiteral<"messagingd">;
+    version: z.ZodString;
+    protocol: z.ZodNumber;
+    pid: z.ZodNumber;
+    deployment: z.ZodOptional<z.ZodLiteral<"jelly">>;
+}, z.core.$strip>;
+export type IpcHello = z.infer<typeof IpcHello>;
+export declare const DaemonStatus: z.ZodObject<{
+    version: z.ZodString;
+    pid: z.ZodNumber;
+    home: z.ZodString;
+    identity: z.ZodOptional<z.ZodObject<{
+        device: z.ZodString;
+        person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+        label: z.ZodString;
+    }, z.core.$strip>>;
+    team: z.ZodOptional<z.ZodObject<{
+        id: z.ZodString;
+        name: z.ZodString;
+        role: z.ZodEnum<{
+            admin: "admin";
+            member: "member";
+        }>;
+        head: z.ZodObject<{
+            seq: z.ZodNumber;
+            hash: z.ZodString;
+        }, z.core.$strip>;
+    }, z.core.$strip>>;
+    relay: z.ZodObject<{
+        url: z.ZodOptional<z.ZodString>;
+        connected: z.ZodBoolean;
+        lastError: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>;
+    sessions: z.ZodNumber;
+    divergence: z.ZodOptional<z.ZodObject<{
+        device: z.ZodString;
+        person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+        seq: z.ZodNumber;
+        ours: z.ZodString;
+        theirs: z.ZodString;
+        at: z.ZodNumber;
+        id: z.ZodString;
+    }, z.core.$strip>>;
+    alarm: z.ZodOptional<z.ZodEnum<{
+        restored: "restored";
+        keys_missing: "keys_missing";
+    }>>;
+    directory: z.ZodOptional<z.ZodObject<{
+        realm: z.ZodEnum<{
+            roster: "roster";
+            directory: "directory";
+        }>;
+        device: z.ZodOptional<z.ZodString>;
+        binding: z.ZodEnum<{
+            removed: "removed";
+            none: "none";
+            bound: "bound";
+            "attest-due": "attest-due";
+            replace: "replace";
+        }>;
+        person: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+        label: z.ZodOptional<z.ZodString>;
+        sth: z.ZodOptional<z.ZodObject<{
+            size: z.ZodNumber;
+            root: z.ZodString;
+            ts: z.ZodNumber;
+        }, z.core.$strip>>;
+        alarm: z.ZodOptional<z.ZodObject<{
+            kind: z.ZodEnum<{
+                directory: "directory";
+                restored: "restored";
+            }>;
+            reason: z.ZodString;
+            at: z.ZodNumber;
+        }, z.core.$strip>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type DaemonStatus = z.infer<typeof DaemonStatus>;
+export declare const InviteSummary: z.ZodObject<{
+    inviteId: z.ZodString;
+    person: z.ZodString;
+    expires: z.ZodNumber;
+    state: z.ZodEnum<{
+        expired: "expired";
+        open: "open";
+        redeemed: "redeemed";
+        revoked: "revoked";
+    }>;
+}, z.core.$strip>;
+/** Method table: name → params/result schemas. The daemon validates params; clients validate results. */
+export declare const IPC_METHODS: {
+    readonly "contacts.list": {
+        readonly params: z.ZodObject<{
+            person: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+            includeOffline: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            entries: z.ZodArray<z.ZodObject<{
+                address: z.ZodString;
+                person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+                agent: z.ZodString;
+                device: z.ZodString;
+                label: z.ZodString;
+                client: z.ZodString;
+                repo: z.ZodOptional<z.ZodString>;
+                branch: z.ZodOptional<z.ZodString>;
+                state: z.ZodEnum<{
+                    idle: "idle";
+                    busy: "busy";
+                }>;
+                doing: z.ZodOptional<z.ZodString>;
+                tier: z.ZodEnum<{
+                    push: "push";
+                    pull: "pull";
+                }>;
+                online: z.ZodBoolean;
+                lastSeen: z.ZodNumber;
+                self: z.ZodBoolean;
+                expect: z.ZodOptional<z.ZodEnum<{
+                    kept: "kept";
+                    next_turn: "next_turn";
+                    wake: "wake";
+                    next_prompt: "next_prompt";
+                    on_read: "on_read";
+                    offline: "offline";
+                }>>;
+            }, z.core.$strip>>;
+            conversations: z.ZodArray<z.ZodObject<{
+                conversation: z.ZodString;
+                kind: z.ZodEnum<{
+                    channel: "channel";
+                    dm: "dm";
+                }>;
+                lastAt: z.ZodOptional<z.ZodNumber>;
+                name: z.ZodOptional<z.ZodString>;
+                lastSeq: z.ZodOptional<z.ZodNumber>;
+                readUpTo: z.ZodNumber;
+                unread: z.ZodNumber;
+            }, z.core.$strip>>;
+            reach: z.ZodArray<z.ZodObject<{
+                person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+                can: z.ZodObject<{
+                    chat: z.ZodBoolean;
+                    agentMail: z.ZodBoolean;
+                    ask: z.ZodEnum<{
+                        open: "open";
+                        request: "request";
+                        no: "no";
+                    }>;
+                    trustedUntil: z.ZodOptional<z.ZodNumber>;
+                }, z.core.$strict>;
+                source: z.ZodEnum<{
+                    default: "default";
+                    card: "card";
+                }>;
+                at: z.ZodOptional<z.ZodNumber>;
+                devicesChangedAt: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    readonly "msg.send": {
+        readonly params: z.ZodObject<{
+            key: z.ZodString;
+            to: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+            kind: z.ZodEnum<{
+                message: "message";
+                task: "task";
+            }>;
+            parts: z.ZodArray<z.ZodObject<{
+                text: z.ZodOptional<z.ZodString>;
+                raw: z.ZodOptional<z.ZodString>;
+                url: z.ZodOptional<z.ZodString>;
+                data: z.ZodOptional<z.ZodUnknown>;
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                filename: z.ZodOptional<z.ZodString>;
+                mediaType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            contextId: z.ZodOptional<z.ZodString>;
+            taskId: z.ZodOptional<z.ZodString>;
+            replyTo: z.ZodOptional<z.ZodString>;
+            idempotencyKey: z.ZodOptional<z.ZodString>;
+            messageId: z.ZodOptional<z.ZodString>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            referenceTaskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            wake: z.ZodOptional<z.ZodBoolean>;
+            request: z.ZodOptional<z.ZodObject<{
+                contact: z.ZodString;
+            }, z.core.$strict>>;
+            onBehalfOf: z.ZodOptional<z.ZodObject<{
+                taskId: z.ZodString;
+                scope: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                maxDepth: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            results: z.ZodArray<z.ZodObject<{
+                to: z.ZodUnion<readonly [z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodString]>, z.ZodString]>;
+                envelopeId: z.ZodString;
+                messageId: z.ZodString;
+                taskId: z.ZodOptional<z.ZodString>;
+                contextId: z.ZodString;
+                stage: z.ZodEnum<{
+                    accepted: "accepted";
+                    relayed: "relayed";
+                    delivered: "delivered";
+                    held: "held";
+                    handed_to_agent: "handed_to_agent";
+                    read: "read";
+                    replied: "replied";
+                    rejected: "rejected";
+                    expired: "expired";
+                }>;
+                code: z.ZodOptional<z.ZodEnum<{
+                    expired: "expired";
+                    invalid_request: "invalid_request";
+                    not_member: "not_member";
+                    bad_signature: "bad_signature";
+                    unknown_session: "unknown_session";
+                    ambiguous_address: "ambiguous_address";
+                    no_recipients: "no_recipients";
+                    unknown_address: "unknown_address";
+                    refused: "refused";
+                    declined: "declined";
+                    request_required: "request_required";
+                    rate_limited: "rate_limited";
+                    loop_guard: "loop_guard";
+                    too_large: "too_large";
+                    secret_refused: "secret_refused";
+                    duplicate: "duplicate";
+                    relay_unavailable: "relay_unavailable";
+                    not_found: "not_found";
+                    invalid_state: "invalid_state";
+                    forbidden: "forbidden";
+                    guarded_turn: "guarded_turn";
+                    roster_conflict: "roster_conflict";
+                    invite_invalid: "invite_invalid";
+                    no_identity: "no_identity";
+                    binding_invalid: "binding_invalid";
+                    jelly_unavailable: "jelly_unavailable";
+                    log_conflict: "log_conflict";
+                    conv_conflict: "conv_conflict";
+                    stale_epoch: "stale_epoch";
+                    device_limit: "device_limit";
+                    admission_required: "admission_required";
+                    admission_invalid: "admission_invalid";
+                    directory_inconsistent: "directory_inconsistent";
+                    unknown_device: "unknown_device";
+                    directory_unavailable: "directory_unavailable";
+                    login_unsupported: "login_unsupported";
+                    login_denied: "login_denied";
+                    grant_required: "grant_required";
+                    grant_invalid: "grant_invalid";
+                    ticket_required: "ticket_required";
+                    ticket_invalid: "ticket_invalid";
+                    daemon_unavailable: "daemon_unavailable";
+                    daemon_mismatch: "daemon_mismatch";
+                    store_refused: "store_refused";
+                    internal: "internal";
+                }>>;
+                expect: z.ZodOptional<z.ZodEnum<{
+                    kept: "kept";
+                    next_turn: "next_turn";
+                    wake: "wake";
+                    next_prompt: "next_prompt";
+                    on_read: "on_read";
+                    offline: "offline";
+                }>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    readonly "item.read": {
+        readonly params: z.ZodObject<{
+            key: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$strict>;
+        readonly result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"received">;
+            item: z.ZodObject<{
+                id: z.ZodString;
+                key: z.ZodString;
+                from: z.ZodObject<{
+                    address: z.ZodString;
+                    person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+                    agent: z.ZodOptional<z.ZodString>;
+                    device: z.ZodString;
+                    label: z.ZodString;
+                }, z.core.$strip>;
+                kind: z.ZodEnum<{
+                    message: "message";
+                    task: "task";
+                }>;
+                messageId: z.ZodString;
+                taskId: z.ZodOptional<z.ZodString>;
+                contextId: z.ZodOptional<z.ZodString>;
+                replyTo: z.ZodOptional<z.ZodString>;
+                receivedAt: z.ZodNumber;
+                stage: z.ZodEnum<{
+                    delivered: "delivered";
+                    handed_to_agent: "handed_to_agent";
+                    read: "read";
+                }>;
+                bytes: z.ZodNumber;
+                preview: z.ZodString;
+                wake: z.ZodBoolean;
+                chain: z.ZodOptional<z.ZodObject<{
+                    addresses: z.ZodArray<z.ZodString>;
+                    depth: z.ZodNumber;
+                    maxDepth: z.ZodNumber;
+                    scope: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    exp: z.ZodNumber;
+                }, z.core.$strip>>;
+                consent: z.ZodOptional<z.ZodEnum<{
+                    self: "self";
+                    guarded: "guarded";
+                    trusted: "trusted";
+                }>>;
+            }, z.core.$strip>;
+            message: z.ZodObject<{
+                messageId: z.ZodString;
+                contextId: z.ZodOptional<z.ZodString>;
+                taskId: z.ZodOptional<z.ZodString>;
+                role: z.ZodEnum<{
+                    ROLE_USER: "ROLE_USER";
+                    ROLE_AGENT: "ROLE_AGENT";
+                }>;
+                parts: z.ZodArray<z.ZodObject<{
+                    text: z.ZodOptional<z.ZodString>;
+                    raw: z.ZodOptional<z.ZodString>;
+                    url: z.ZodOptional<z.ZodString>;
+                    data: z.ZodOptional<z.ZodUnknown>;
+                    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    filename: z.ZodOptional<z.ZodString>;
+                    mediaType: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                referenceTaskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"sent">;
+            envelopeId: z.ZodString;
+            to: z.ZodUnion<readonly [z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodString]>, z.ZodString]>;
+            stage: z.ZodEnum<{
+                accepted: "accepted";
+                relayed: "relayed";
+                delivered: "delivered";
+                held: "held";
+                handed_to_agent: "handed_to_agent";
+                read: "read";
+                replied: "replied";
+                rejected: "rejected";
+                expired: "expired";
+            }>;
+            history: z.ZodArray<z.ZodObject<{
+                stage: z.ZodEnum<{
+                    accepted: "accepted";
+                    relayed: "relayed";
+                    delivered: "delivered";
+                    held: "held";
+                    handed_to_agent: "handed_to_agent";
+                    read: "read";
+                    replied: "replied";
+                    rejected: "rejected";
+                    expired: "expired";
+                }>;
+                at: z.ZodNumber;
+                code: z.ZodOptional<z.ZodEnum<{
+                    expired: "expired";
+                    invalid_request: "invalid_request";
+                    not_member: "not_member";
+                    bad_signature: "bad_signature";
+                    unknown_session: "unknown_session";
+                    ambiguous_address: "ambiguous_address";
+                    no_recipients: "no_recipients";
+                    unknown_address: "unknown_address";
+                    refused: "refused";
+                    declined: "declined";
+                    request_required: "request_required";
+                    rate_limited: "rate_limited";
+                    loop_guard: "loop_guard";
+                    too_large: "too_large";
+                    secret_refused: "secret_refused";
+                    duplicate: "duplicate";
+                    relay_unavailable: "relay_unavailable";
+                    not_found: "not_found";
+                    invalid_state: "invalid_state";
+                    forbidden: "forbidden";
+                    guarded_turn: "guarded_turn";
+                    roster_conflict: "roster_conflict";
+                    invite_invalid: "invite_invalid";
+                    no_identity: "no_identity";
+                    binding_invalid: "binding_invalid";
+                    jelly_unavailable: "jelly_unavailable";
+                    log_conflict: "log_conflict";
+                    conv_conflict: "conv_conflict";
+                    stale_epoch: "stale_epoch";
+                    device_limit: "device_limit";
+                    admission_required: "admission_required";
+                    admission_invalid: "admission_invalid";
+                    directory_inconsistent: "directory_inconsistent";
+                    unknown_device: "unknown_device";
+                    directory_unavailable: "directory_unavailable";
+                    login_unsupported: "login_unsupported";
+                    login_denied: "login_denied";
+                    grant_required: "grant_required";
+                    grant_invalid: "grant_invalid";
+                    ticket_required: "ticket_required";
+                    ticket_invalid: "ticket_invalid";
+                    daemon_unavailable: "daemon_unavailable";
+                    daemon_mismatch: "daemon_mismatch";
+                    store_refused: "store_refused";
+                    internal: "internal";
+                }>>;
+                note: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>], "kind">;
+    };
+    readonly "conv.read": {
+        readonly params: z.ZodObject<{
+            key: z.ZodOptional<z.ZodString>;
+            conversation: z.ZodString;
+            thread: z.ZodOptional<z.ZodString>;
+            before: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+                at: z.ZodNumber;
+                id: z.ZodString;
+            }, z.core.$strict>]>>;
+            after: z.ZodOptional<z.ZodUnion<readonly [z.ZodNumber, z.ZodObject<{
+                at: z.ZodNumber;
+                id: z.ZodString;
+            }, z.core.$strict>]>>;
+            limit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        readonly result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"lines">;
+            lines: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                seq: z.ZodNumber;
+                at: z.ZodNumber;
+                person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+                agent: z.ZodOptional<z.ZodString>;
+                direction: z.ZodEnum<{
+                    out: "out";
+                    in: "in";
+                }>;
+                body: z.ZodString;
+                thread: z.ZodOptional<z.ZodString>;
+                state: z.ZodOptional<z.ZodEnum<{
+                    delivered: "delivered";
+                    held: "held";
+                    refused: "refused";
+                    sent: "sent";
+                }>>;
+                refused: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>>;
+                notice: z.ZodOptional<z.ZodLiteral<true>>;
+            }, z.core.$strip>>;
+            more: z.ZodBoolean;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"agent">;
+            entries: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodEnum<{
+                    task: "task";
+                    mail: "mail";
+                }>;
+                direction: z.ZodEnum<{
+                    out: "out";
+                    in: "in";
+                }>;
+                peer: z.ZodString;
+                at: z.ZodNumber;
+                text: z.ZodOptional<z.ZodString>;
+                taskId: z.ZodOptional<z.ZodString>;
+                stage: z.ZodOptional<z.ZodEnum<{
+                    accepted: "accepted";
+                    relayed: "relayed";
+                    delivered: "delivered";
+                    held: "held";
+                    handed_to_agent: "handed_to_agent";
+                    read: "read";
+                    replied: "replied";
+                    rejected: "rejected";
+                    expired: "expired";
+                }>>;
+                role: z.ZodOptional<z.ZodEnum<{
+                    requester: "requester";
+                    executor: "executor";
+                }>>;
+                state: z.ZodOptional<z.ZodEnum<{
+                    TASK_STATE_SUBMITTED: "TASK_STATE_SUBMITTED";
+                    TASK_STATE_WORKING: "TASK_STATE_WORKING";
+                    TASK_STATE_COMPLETED: "TASK_STATE_COMPLETED";
+                    TASK_STATE_FAILED: "TASK_STATE_FAILED";
+                    TASK_STATE_CANCELED: "TASK_STATE_CANCELED";
+                    TASK_STATE_INPUT_REQUIRED: "TASK_STATE_INPUT_REQUIRED";
+                    TASK_STATE_REJECTED: "TASK_STATE_REJECTED";
+                    TASK_STATE_AUTH_REQUIRED: "TASK_STATE_AUTH_REQUIRED";
+                }>>;
+            }, z.core.$strip>>;
+            more: z.ZodBoolean;
+        }, z.core.$strip>], "kind">;
+    };
+    readonly search: {
+        readonly params: z.ZodObject<{
+            query: z.ZodString;
+            conversation: z.ZodOptional<z.ZodString>;
+            limit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            hits: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                seq: z.ZodNumber;
+                at: z.ZodNumber;
+                person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+                agent: z.ZodOptional<z.ZodString>;
+                direction: z.ZodEnum<{
+                    out: "out";
+                    in: "in";
+                }>;
+                body: z.ZodString;
+                thread: z.ZodOptional<z.ZodString>;
+                state: z.ZodOptional<z.ZodEnum<{
+                    delivered: "delivered";
+                    held: "held";
+                    refused: "refused";
+                    sent: "sent";
+                }>>;
+                refused: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>>;
+                notice: z.ZodOptional<z.ZodLiteral<true>>;
+                conversation: z.ZodString;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    readonly "conv.list": {
+        readonly params: z.ZodObject<{
+            limit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            conversations: z.ZodArray<z.ZodObject<{
+                conversation: z.ZodString;
+                kind: z.ZodEnum<{
+                    channel: "channel";
+                    dm: "dm";
+                }>;
+                lastAt: z.ZodOptional<z.ZodNumber>;
+                name: z.ZodOptional<z.ZodString>;
+                lastSeq: z.ZodOptional<z.ZodNumber>;
+                readUpTo: z.ZodNumber;
+                unread: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    readonly "conv.markRead": {
+        readonly params: z.ZodObject<{
+            conversation: z.ZodString;
+            upTo: z.ZodNumber;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            readUpTo: z.ZodNumber;
+            unread: z.ZodNumber;
+        }, z.core.$strip>;
+    };
+    readonly "conv.subscribe": {
+        readonly params: z.ZodObject<{
+            since: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            seq: z.ZodNumber;
+            gap: z.ZodBoolean;
+        }, z.core.$strip>;
+    };
+    readonly "person.send": {
+        readonly params: z.ZodObject<{
+            conversation: z.ZodString;
+            text: z.ZodString;
+            thread: z.ZodOptional<z.ZodString>;
+            clientId: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            id: z.ZodString;
+            conversation: z.ZodString;
+        }, z.core.$strip>;
+    };
+    readonly "people.search": {
+        readonly params: z.ZodObject<{
+            query: z.ZodOptional<z.ZodString>;
+            limit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            people: z.ZodArray<z.ZodObject<{
+                person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+                name: z.ZodString;
+                handle: z.ZodString;
+                org: z.ZodEnum<{
+                    other: "other";
+                    none: "none";
+                    same: "same";
+                }>;
+                vouched: z.ZodEnum<{
+                    admin: "admin";
+                    device: "device";
+                    jelly: "jelly";
+                    service: "service";
+                }>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    readonly "people.get": {
+        readonly params: z.ZodObject<{
+            person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+            name: z.ZodString;
+            handle: z.ZodString;
+            org: z.ZodEnum<{
+                other: "other";
+                none: "none";
+                same: "same";
+            }>;
+            vouched: z.ZodEnum<{
+                admin: "admin";
+                device: "device";
+                jelly: "jelly";
+                service: "service";
+            }>;
+            devices: z.ZodArray<z.ZodObject<{
+                device: z.ZodString;
+                label: z.ZodString;
+                self: z.ZodBoolean;
+                away: z.ZodOptional<z.ZodLiteral<true>>;
+            }, z.core.$strip>>;
+            deviceChanges: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                change: z.ZodEnum<{
+                    removed: "removed";
+                    replaced: "replaced";
+                    added: "added";
+                    vouched: "vouched";
+                }>;
+                device: z.ZodString;
+                label: z.ZodString;
+                kind: z.ZodOptional<z.ZodEnum<{
+                    "jelly-host": "jelly-host";
+                    laptop: "laptop";
+                    server: "server";
+                    other: "other";
+                }>>;
+                vouch: z.ZodEnum<{
+                    admin: "admin";
+                    device: "device";
+                    jelly: "jelly";
+                }>;
+                via: z.ZodOptional<z.ZodEnum<{
+                    host: "host";
+                    browser: "browser";
+                }>>;
+                approver: z.ZodOptional<z.ZodString>;
+                at: z.ZodNumber;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+    };
+    readonly "daemon.health": {
+        readonly params: z.ZodObject<{}, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            state: z.ZodEnum<{
+                starting: "starting";
+                running: "running";
+                stopping: "stopping";
+            }>;
+            relay: z.ZodEnum<{
+                offline: "offline";
+                connected: "connected";
+                connecting: "connecting";
+            }>;
+            directory: z.ZodEnum<{
+                alarm: "alarm";
+                ok: "ok";
+                unavailable: "unavailable";
+            }>;
+            alarm: z.ZodNullable<z.ZodEnum<{
+                directory: "directory";
+                restored: "restored";
+                keys_missing: "keys_missing";
+            }>>;
+            busy: z.ZodBoolean;
+            version: z.ZodString;
+            storeSchema: z.ZodNumber;
+        }, z.core.$strip>;
+    };
+    readonly "agents.list": {
+        readonly params: z.ZodObject<{}, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            agents: z.ZodArray<z.ZodObject<{
+                agent: z.ZodString;
+                conversations: z.ZodNumber;
+                unread: z.ZodNumber;
+                lastAt: z.ZodOptional<z.ZodNumber>;
+                state: z.ZodEnum<{
+                    idle: "idle";
+                    busy: "busy";
+                    kept: "kept";
+                }>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    readonly "agents.read": {
+        readonly params: z.ZodObject<{
+            agent: z.ZodString;
+            conversation: z.ZodOptional<z.ZodString>;
+            before: z.ZodOptional<z.ZodObject<{
+                at: z.ZodNumber;
+                id: z.ZodString;
+            }, z.core.$strict>>;
+            limit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        readonly result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            kind: z.ZodLiteral<"conversations">;
+            conversations: z.ZodArray<z.ZodObject<{
+                conversation: z.ZodString;
+                unread: z.ZodNumber;
+                lastAt: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            kind: z.ZodLiteral<"entries">;
+            conversation: z.ZodString;
+            entries: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodEnum<{
+                    task: "task";
+                    mail: "mail";
+                }>;
+                direction: z.ZodEnum<{
+                    out: "out";
+                    in: "in";
+                }>;
+                peer: z.ZodString;
+                at: z.ZodNumber;
+                text: z.ZodOptional<z.ZodString>;
+                taskId: z.ZodOptional<z.ZodString>;
+                stage: z.ZodOptional<z.ZodEnum<{
+                    accepted: "accepted";
+                    relayed: "relayed";
+                    delivered: "delivered";
+                    held: "held";
+                    handed_to_agent: "handed_to_agent";
+                    read: "read";
+                    replied: "replied";
+                    rejected: "rejected";
+                    expired: "expired";
+                }>>;
+                role: z.ZodOptional<z.ZodEnum<{
+                    requester: "requester";
+                    executor: "executor";
+                }>>;
+                state: z.ZodOptional<z.ZodEnum<{
+                    TASK_STATE_SUBMITTED: "TASK_STATE_SUBMITTED";
+                    TASK_STATE_WORKING: "TASK_STATE_WORKING";
+                    TASK_STATE_COMPLETED: "TASK_STATE_COMPLETED";
+                    TASK_STATE_FAILED: "TASK_STATE_FAILED";
+                    TASK_STATE_CANCELED: "TASK_STATE_CANCELED";
+                    TASK_STATE_INPUT_REQUIRED: "TASK_STATE_INPUT_REQUIRED";
+                    TASK_STATE_REJECTED: "TASK_STATE_REJECTED";
+                    TASK_STATE_AUTH_REQUIRED: "TASK_STATE_AUTH_REQUIRED";
+                }>>;
+            }, z.core.$strip>>;
+            more: z.ZodBoolean;
+        }, z.core.$strip>], "kind">;
+    };
+    readonly "notice.subscribe": {
+        readonly params: z.ZodObject<{
+            after: z.ZodOptional<z.ZodString>;
+            lines: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            replayed: z.ZodNumber;
+        }, z.core.$strip>;
+    };
+    readonly "notice.list": {
+        readonly params: z.ZodObject<{
+            lines: z.ZodOptional<z.ZodBoolean>;
+            limit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            notices: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                category: z.ZodEnum<{
+                    message: "message";
+                    request: "request";
+                    alert: "alert";
+                }>;
+                conversation: z.ZodOptional<z.ZodString>;
+                from: z.ZodOptional<z.ZodObject<{
+                    name: z.ZodString;
+                    email: z.ZodOptional<z.ZodString>;
+                    org: z.ZodEnum<{
+                        other: "other";
+                        none: "none";
+                        same: "same";
+                    }>;
+                }, z.core.$strip>>;
+                line: z.ZodOptional<z.ZodString>;
+                device: z.ZodOptional<z.ZodObject<{
+                    change: z.ZodEnum<{
+                        removed: "removed";
+                        replaced: "replaced";
+                        added: "added";
+                        vouched: "vouched";
+                    }>;
+                    device: z.ZodString;
+                    label: z.ZodString;
+                    kind: z.ZodOptional<z.ZodEnum<{
+                        "jelly-host": "jelly-host";
+                        laptop: "laptop";
+                        server: "server";
+                        other: "other";
+                    }>>;
+                    vouch: z.ZodEnum<{
+                        admin: "admin";
+                        device: "device";
+                        jelly: "jelly";
+                    }>;
+                    via: z.ZodOptional<z.ZodEnum<{
+                        host: "host";
+                        browser: "browser";
+                    }>>;
+                    approver: z.ZodOptional<z.ZodString>;
+                    at: z.ZodNumber;
+                    replaces: z.ZodOptional<z.ZodObject<{
+                        device: z.ZodString;
+                        label: z.ZodString;
+                    }, z.core.$strip>>;
+                    current: z.ZodBoolean;
+                    remove: z.ZodOptional<z.ZodEnum<{
+                        token: "token";
+                        "sign-in": "sign-in";
+                        team: "team";
+                    }>>;
+                }, z.core.$strip>>;
+                at: z.ZodNumber;
+            }, z.core.$strip>>;
+            counts: z.ZodObject<{
+                unread: z.ZodNumber;
+                requests: z.ZodNumber;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    };
+    readonly "notice.ack": {
+        readonly params: z.ZodObject<{
+            ids: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+    };
+    readonly "daemon.woke": {
+        readonly params: z.ZodObject<{}, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+    };
+    readonly "person.attached": {
+        readonly params: z.ZodObject<{
+            attached: z.ZodBoolean;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+    };
+    readonly "wake.arm": {
+        readonly params: z.ZodObject<{
+            url: z.ZodString;
+            ticket: z.ZodString;
+            agents: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            relay: z.ZodEnum<{
+                pending: "pending";
+                armed: "armed";
+            }>;
+            awaiting: z.ZodNumber;
+        }, z.core.$strip>;
+    };
+    readonly "wake.disarm": {
+        readonly params: z.ZodObject<{}, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            relay: z.ZodEnum<{
+                pending: "pending";
+                disarmed: "disarmed";
+            }>;
+        }, z.core.$strip>;
+    };
+    readonly "daemon.snapshot": {
+        readonly params: z.ZodObject<{
+            done: z.ZodOptional<z.ZodLiteral<true>>;
+        }, z.core.$strict>;
+        readonly result: z.ZodUnion<readonly [z.ZodObject<{
+            folder: z.ZodString;
+            files: z.ZodArray<z.ZodObject<{
+                name: z.ZodString;
+                bytes: z.ZodNumber;
+                sha256: z.ZodString;
+            }, z.core.$strip>>;
+            storeSchema: z.ZodNumber;
+            at: z.ZodNumber;
+            until: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            released: z.ZodBoolean;
+        }, z.core.$strip>]>;
+    };
+    readonly "device.remove.preview": {
+        readonly params: z.ZodObject<{
+            device: z.ZodString;
+            reason: z.ZodOptional<z.ZodEnum<{
+                self: "self";
+                removed: "removed";
+                lost: "lost";
+            }>>;
+            token: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            label: z.ZodString;
+            kind: z.ZodOptional<z.ZodEnum<{
+                "jelly-host": "jelly-host";
+                laptop: "laptop";
+                server: "server";
+                other: "other";
+            }>>;
+            vouch: z.ZodEnum<{
+                admin: "admin";
+                device: "device";
+                jelly: "jelly";
+            }>;
+            current: z.ZodBoolean;
+            self: z.ZodBoolean;
+            since: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strip>;
+    };
+    readonly "grant.list": {
+        readonly params: z.ZodObject<{
+            subject: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+                person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+            }, z.core.$strict>, z.ZodObject<{
+                channel: z.ZodString;
+            }, z.core.$strict>]>>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            grants: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                ts: z.ZodNumber;
+                by: z.ZodString;
+                resignedAt: z.ZodOptional<z.ZodNumber>;
+                chat: z.ZodOptional<z.ZodEnum<{
+                    open: "open";
+                    muted: "muted";
+                    blocked: "blocked";
+                }>>;
+                agentMail: z.ZodOptional<z.ZodEnum<{
+                    open: "open";
+                    blocked: "blocked";
+                }>>;
+                ask: z.ZodOptional<z.ZodEnum<{
+                    open: "open";
+                    request: "request";
+                    no: "no";
+                }>>;
+                trustedUntil: z.ZodOptional<z.ZodNumber>;
+                discoverable: z.ZodOptional<z.ZodBoolean>;
+                subject: z.ZodUnion<readonly [z.ZodObject<{
+                    person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+                }, z.core.$strip>, z.ZodObject<{
+                    channel: z.ZodString;
+                    name: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>]>;
+            }, z.core.$strip>>;
+            review: z.ZodArray<z.ZodObject<{
+                subject: z.ZodUnion<readonly [z.ZodObject<{
+                    person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+                }, z.core.$strip>, z.ZodObject<{
+                    channel: z.ZodString;
+                    name: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>]>;
+                chat: z.ZodOptional<z.ZodLiteral<"open">>;
+                agentMail: z.ZodOptional<z.ZodLiteral<"open">>;
+                ask: z.ZodOptional<z.ZodEnum<{
+                    open: "open";
+                    request: "request";
+                }>>;
+                trustedUntil: z.ZodOptional<z.ZodNumber>;
+                discoverable: z.ZodOptional<z.ZodLiteral<true>>;
+                at: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    readonly "grant.set": {
+        readonly params: z.ZodObject<{
+            trust: z.ZodOptional<z.ZodLiteral<true>>;
+            chat: z.ZodOptional<z.ZodEnum<{
+                open: "open";
+                muted: "muted";
+                blocked: "blocked";
+            }>>;
+            agentMail: z.ZodOptional<z.ZodEnum<{
+                open: "open";
+                blocked: "blocked";
+            }>>;
+            ask: z.ZodOptional<z.ZodEnum<{
+                open: "open";
+                request: "request";
+                no: "no";
+            }>>;
+            trustedUntil: z.ZodOptional<z.ZodNumber>;
+            discoverable: z.ZodOptional<z.ZodBoolean>;
+            subject: z.ZodUnion<readonly [z.ZodObject<{
+                person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+            }, z.core.$strict>, z.ZodObject<{
+                channel: z.ZodString;
+            }, z.core.$strict>]>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            grant: z.ZodObject<{
+                id: z.ZodString;
+                ts: z.ZodNumber;
+                by: z.ZodString;
+                resignedAt: z.ZodOptional<z.ZodNumber>;
+                chat: z.ZodOptional<z.ZodEnum<{
+                    open: "open";
+                    muted: "muted";
+                    blocked: "blocked";
+                }>>;
+                agentMail: z.ZodOptional<z.ZodEnum<{
+                    open: "open";
+                    blocked: "blocked";
+                }>>;
+                ask: z.ZodOptional<z.ZodEnum<{
+                    open: "open";
+                    request: "request";
+                    no: "no";
+                }>>;
+                trustedUntil: z.ZodOptional<z.ZodNumber>;
+                discoverable: z.ZodOptional<z.ZodBoolean>;
+                subject: z.ZodUnion<readonly [z.ZodObject<{
+                    person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+                }, z.core.$strip>, z.ZodObject<{
+                    channel: z.ZodString;
+                    name: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>]>;
+            }, z.core.$strip>;
+        }, z.core.$strip>;
+    };
+    readonly "grant.set.preview": {
+        readonly params: z.ZodObject<{
+            trust: z.ZodOptional<z.ZodLiteral<true>>;
+            chat: z.ZodOptional<z.ZodEnum<{
+                open: "open";
+                muted: "muted";
+                blocked: "blocked";
+            }>>;
+            agentMail: z.ZodOptional<z.ZodEnum<{
+                open: "open";
+                blocked: "blocked";
+            }>>;
+            ask: z.ZodOptional<z.ZodEnum<{
+                open: "open";
+                request: "request";
+                no: "no";
+            }>>;
+            trustedUntil: z.ZodOptional<z.ZodNumber>;
+            discoverable: z.ZodOptional<z.ZodBoolean>;
+            subject: z.ZodUnion<readonly [z.ZodObject<{
+                person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+            }, z.core.$strict>, z.ZodObject<{
+                channel: z.ZodString;
+            }, z.core.$strict>]>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            sentence: z.ZodString;
+        }, z.core.$strip>;
+    };
+    readonly "request.list": {
+        readonly params: z.ZodObject<{}, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            requests: z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodEnum<{
+                    message: "message";
+                    task: "task";
+                }>;
+                from: z.ZodObject<{
+                    person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+                    device: z.ZodString;
+                    label: z.ZodString;
+                    agent: z.ZodString;
+                    address: z.ZodString;
+                }, z.core.$strip>;
+                to: z.ZodString;
+                preview: z.ZodString;
+                at: z.ZodNumber;
+                exp: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodLiteral<"contact">;
+                from: z.ZodObject<{
+                    person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+                    device: z.ZodString;
+                    label: z.ZodString;
+                    name: z.ZodString;
+                    email: z.ZodOptional<z.ZodString>;
+                    org: z.ZodEnum<{
+                        other: "other";
+                        none: "none";
+                        same: "same";
+                    }>;
+                }, z.core.$strip>;
+                text: z.ZodString;
+                at: z.ZodNumber;
+                exp: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodLiteral<"suggestion">;
+                agent: z.ZodString;
+                email: z.ZodString;
+                at: z.ZodNumber;
+            }, z.core.$strip>]>>;
+        }, z.core.$strip>;
+    };
+    readonly "request.answer": {
+        readonly params: z.ZodObject<{
+            id: z.ZodString;
+            answer: z.ZodEnum<{
+                once: "once";
+                always: "always";
+                accept: "accept";
+                decline: "decline";
+                block: "block";
+            }>;
+            all: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            answered: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+    };
+    readonly "request.answer.preview": {
+        readonly params: z.ZodObject<{
+            id: z.ZodString;
+            answer: z.ZodEnum<{
+                once: "once";
+                always: "always";
+                accept: "accept";
+                decline: "decline";
+                block: "block";
+            }>;
+            all: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            kind: z.ZodEnum<{
+                message: "message";
+                task: "task";
+                contact: "contact";
+                suggestion: "suggestion";
+            }>;
+            from: z.ZodObject<{
+                name: z.ZodString;
+                email: z.ZodOptional<z.ZodString>;
+                org: z.ZodEnum<{
+                    other: "other";
+                    none: "none";
+                    same: "same";
+                }>;
+            }, z.core.$strip>;
+            agent: z.ZodOptional<z.ZodString>;
+            to: z.ZodOptional<z.ZodString>;
+            count: z.ZodNumber;
+            sentence: z.ZodString;
+        }, z.core.$strip>;
+    };
+    readonly "contact.request": {
+        readonly params: z.ZodObject<{
+            email: z.ZodString;
+            text: z.ZodString;
+            suggestion: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            id: z.ZodString;
+            conversation: z.ZodString;
+            person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+        }, z.core.$strip>;
+    };
+    readonly "contact.request.preview": {
+        readonly params: z.ZodObject<{
+            email: z.ZodString;
+            text: z.ZodOptional<z.ZodString>;
+            suggestion: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            found: z.ZodBoolean;
+        }, z.core.$strip>;
+    };
+    readonly "card.get": {
+        readonly params: z.ZodObject<{
+            person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            sent: z.ZodBoolean;
+        }, z.core.$strip>;
+    };
+    readonly "daemon.status": {
+        readonly params: z.ZodObject<{}, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            version: z.ZodString;
+            pid: z.ZodNumber;
+            home: z.ZodString;
+            identity: z.ZodOptional<z.ZodObject<{
+                device: z.ZodString;
+                person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+                label: z.ZodString;
+            }, z.core.$strip>>;
+            team: z.ZodOptional<z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+                role: z.ZodEnum<{
+                    admin: "admin";
+                    member: "member";
+                }>;
+                head: z.ZodObject<{
+                    seq: z.ZodNumber;
+                    hash: z.ZodString;
+                }, z.core.$strip>;
+            }, z.core.$strip>>;
+            relay: z.ZodObject<{
+                url: z.ZodOptional<z.ZodString>;
+                connected: z.ZodBoolean;
+                lastError: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            sessions: z.ZodNumber;
+            divergence: z.ZodOptional<z.ZodObject<{
+                device: z.ZodString;
+                person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+                seq: z.ZodNumber;
+                ours: z.ZodString;
+                theirs: z.ZodString;
+                at: z.ZodNumber;
+                id: z.ZodString;
+            }, z.core.$strip>>;
+            alarm: z.ZodOptional<z.ZodEnum<{
+                restored: "restored";
+                keys_missing: "keys_missing";
+            }>>;
+            directory: z.ZodOptional<z.ZodObject<{
+                realm: z.ZodEnum<{
+                    roster: "roster";
+                    directory: "directory";
+                }>;
+                device: z.ZodOptional<z.ZodString>;
+                binding: z.ZodEnum<{
+                    removed: "removed";
+                    none: "none";
+                    bound: "bound";
+                    "attest-due": "attest-due";
+                    replace: "replace";
+                }>;
+                person: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+                label: z.ZodOptional<z.ZodString>;
+                sth: z.ZodOptional<z.ZodObject<{
+                    size: z.ZodNumber;
+                    root: z.ZodString;
+                    ts: z.ZodNumber;
+                }, z.core.$strip>>;
+                alarm: z.ZodOptional<z.ZodObject<{
+                    kind: z.ZodEnum<{
+                        directory: "directory";
+                        restored: "restored";
+                    }>;
+                    reason: z.ZodString;
+                    at: z.ZodNumber;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    /** Human CLI only: replies, then shuts the daemon down cleanly. */
+    readonly "daemon.stop": {
+        readonly params: z.ZodObject<{}, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+    };
+    readonly "session.register": {
+        readonly params: z.ZodObject<{
+            key: z.ZodString;
+            agent: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            cwd: z.ZodOptional<z.ZodString>;
+            repo: z.ZodOptional<z.ZodString>;
+            branch: z.ZodOptional<z.ZodString>;
+            tier: z.ZodEnum<{
+                push: "push";
+                pull: "pull";
+            }>;
+            state: z.ZodEnum<{
+                idle: "idle";
+                busy: "busy";
+            }>;
+            doing: z.ZodOptional<z.ZodString>;
+            host: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodLiteral<"opencode">;
+                location: z.ZodString;
+                sessionID: z.ZodString;
+                pid: z.ZodNumber;
+            }, z.core.$strict>>;
+            ticket: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            session: z.ZodString;
+            address: z.ZodString;
+        }, z.core.$strip>;
+    };
+    readonly "session.update": {
+        readonly params: z.ZodObject<{
+            key: z.ZodString;
+            state: z.ZodOptional<z.ZodEnum<{
+                idle: "idle";
+                busy: "busy";
+            }>>;
+            doing: z.ZodOptional<z.ZodString>;
+            branch: z.ZodOptional<z.ZodString>;
+            tier: z.ZodOptional<z.ZodEnum<{
+                push: "push";
+                pull: "pull";
+            }>>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+    };
+    readonly "session.unregister": {
+        readonly params: z.ZodObject<{
+            key: z.ZodString;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+    };
+    /** Newest first; default limit 50. */
+    readonly "inbox.list": {
+        readonly params: z.ZodObject<{
+            key: z.ZodString;
+            unreadOnly: z.ZodOptional<z.ZodBoolean>;
+            limit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            items: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                key: z.ZodString;
+                from: z.ZodObject<{
+                    address: z.ZodString;
+                    person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+                    agent: z.ZodOptional<z.ZodString>;
+                    device: z.ZodString;
+                    label: z.ZodString;
+                }, z.core.$strip>;
+                kind: z.ZodEnum<{
+                    message: "message";
+                    task: "task";
+                }>;
+                messageId: z.ZodString;
+                taskId: z.ZodOptional<z.ZodString>;
+                contextId: z.ZodOptional<z.ZodString>;
+                replyTo: z.ZodOptional<z.ZodString>;
+                receivedAt: z.ZodNumber;
+                stage: z.ZodEnum<{
+                    delivered: "delivered";
+                    handed_to_agent: "handed_to_agent";
+                    read: "read";
+                }>;
+                bytes: z.ZodNumber;
+                preview: z.ZodString;
+                wake: z.ZodBoolean;
+                chain: z.ZodOptional<z.ZodObject<{
+                    addresses: z.ZodArray<z.ZodString>;
+                    depth: z.ZodNumber;
+                    maxDepth: z.ZodNumber;
+                    scope: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    exp: z.ZodNumber;
+                }, z.core.$strip>>;
+                consent: z.ZodOptional<z.ZodEnum<{
+                    self: "self";
+                    guarded: "guarded";
+                    trusted: "trusted";
+                }>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    /**
+     * Looks up one item without changing its stage or sending a receipt. With `message: true` it
+     * also returns the full message, still with no stage change: a client can show the message first
+     * and ack after (`inbox.ack`), so a crash in between leaves the item unread.
+     */
+    readonly "inbox.get": {
+        readonly params: z.ZodObject<{
+            key: z.ZodString;
+            id: z.ZodString;
+            message: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            item: z.ZodObject<{
+                id: z.ZodString;
+                key: z.ZodString;
+                from: z.ZodObject<{
+                    address: z.ZodString;
+                    person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+                    agent: z.ZodOptional<z.ZodString>;
+                    device: z.ZodString;
+                    label: z.ZodString;
+                }, z.core.$strip>;
+                kind: z.ZodEnum<{
+                    message: "message";
+                    task: "task";
+                }>;
+                messageId: z.ZodString;
+                taskId: z.ZodOptional<z.ZodString>;
+                contextId: z.ZodOptional<z.ZodString>;
+                replyTo: z.ZodOptional<z.ZodString>;
+                receivedAt: z.ZodNumber;
+                stage: z.ZodEnum<{
+                    delivered: "delivered";
+                    handed_to_agent: "handed_to_agent";
+                    read: "read";
+                }>;
+                bytes: z.ZodNumber;
+                preview: z.ZodString;
+                wake: z.ZodBoolean;
+                chain: z.ZodOptional<z.ZodObject<{
+                    addresses: z.ZodArray<z.ZodString>;
+                    depth: z.ZodNumber;
+                    maxDepth: z.ZodNumber;
+                    scope: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    exp: z.ZodNumber;
+                }, z.core.$strip>>;
+                consent: z.ZodOptional<z.ZodEnum<{
+                    self: "self";
+                    guarded: "guarded";
+                    trusted: "trusted";
+                }>>;
+            }, z.core.$strip>;
+            message: z.ZodOptional<z.ZodObject<{
+                messageId: z.ZodString;
+                contextId: z.ZodOptional<z.ZodString>;
+                taskId: z.ZodOptional<z.ZodString>;
+                role: z.ZodEnum<{
+                    ROLE_USER: "ROLE_USER";
+                    ROLE_AGENT: "ROLE_AGENT";
+                }>;
+                parts: z.ZodArray<z.ZodObject<{
+                    text: z.ZodOptional<z.ZodString>;
+                    raw: z.ZodOptional<z.ZodString>;
+                    url: z.ZodOptional<z.ZodString>;
+                    data: z.ZodOptional<z.ZodUnknown>;
+                    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    filename: z.ZodOptional<z.ZodString>;
+                    mediaType: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                referenceTaskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    readonly "inbox.ack": {
+        readonly params: z.ZodObject<{
+            key: z.ZodString;
+            id: z.ZodString;
+            stage: z.ZodEnum<{
+                handed_to_agent: "handed_to_agent";
+                read: "read";
+            }>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+    };
+    readonly "task.list": {
+        readonly params: z.ZodObject<{
+            key: z.ZodString;
+            role: z.ZodOptional<z.ZodEnum<{
+                requester: "requester";
+                executor: "executor";
+            }>>;
+            state: z.ZodOptional<z.ZodEnum<{
+                TASK_STATE_SUBMITTED: "TASK_STATE_SUBMITTED";
+                TASK_STATE_WORKING: "TASK_STATE_WORKING";
+                TASK_STATE_COMPLETED: "TASK_STATE_COMPLETED";
+                TASK_STATE_FAILED: "TASK_STATE_FAILED";
+                TASK_STATE_CANCELED: "TASK_STATE_CANCELED";
+                TASK_STATE_INPUT_REQUIRED: "TASK_STATE_INPUT_REQUIRED";
+                TASK_STATE_REJECTED: "TASK_STATE_REJECTED";
+                TASK_STATE_AUTH_REQUIRED: "TASK_STATE_AUTH_REQUIRED";
+            }>>;
+            contextId: z.ZodOptional<z.ZodString>;
+            peer: z.ZodOptional<z.ZodString>;
+            updatedAfter: z.ZodOptional<z.ZodNumber>;
+            cursor: z.ZodOptional<z.ZodString>;
+            limit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        /** Most recently updated first. */
+        readonly result: z.ZodObject<{
+            tasks: z.ZodArray<z.ZodObject<{
+                task: z.ZodObject<{
+                    contextId: z.ZodOptional<z.ZodString>;
+                    status: z.ZodObject<{
+                        state: z.ZodEnum<{
+                            TASK_STATE_SUBMITTED: "TASK_STATE_SUBMITTED";
+                            TASK_STATE_WORKING: "TASK_STATE_WORKING";
+                            TASK_STATE_COMPLETED: "TASK_STATE_COMPLETED";
+                            TASK_STATE_FAILED: "TASK_STATE_FAILED";
+                            TASK_STATE_CANCELED: "TASK_STATE_CANCELED";
+                            TASK_STATE_INPUT_REQUIRED: "TASK_STATE_INPUT_REQUIRED";
+                            TASK_STATE_REJECTED: "TASK_STATE_REJECTED";
+                            TASK_STATE_AUTH_REQUIRED: "TASK_STATE_AUTH_REQUIRED";
+                        }>;
+                        message: z.ZodOptional<z.ZodObject<{
+                            messageId: z.ZodString;
+                            contextId: z.ZodOptional<z.ZodString>;
+                            taskId: z.ZodOptional<z.ZodString>;
+                            role: z.ZodEnum<{
+                                ROLE_USER: "ROLE_USER";
+                                ROLE_AGENT: "ROLE_AGENT";
+                            }>;
+                            parts: z.ZodArray<z.ZodObject<{
+                                text: z.ZodOptional<z.ZodString>;
+                                raw: z.ZodOptional<z.ZodString>;
+                                url: z.ZodOptional<z.ZodString>;
+                                data: z.ZodOptional<z.ZodUnknown>;
+                                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                                filename: z.ZodOptional<z.ZodString>;
+                                mediaType: z.ZodOptional<z.ZodString>;
+                            }, z.core.$strip>>;
+                            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                            extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                            referenceTaskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        }, z.core.$strip>>;
+                        timestamp: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>;
+                    artifacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        artifactId: z.ZodString;
+                        name: z.ZodOptional<z.ZodString>;
+                        description: z.ZodOptional<z.ZodString>;
+                        parts: z.ZodArray<z.ZodObject<{
+                            text: z.ZodOptional<z.ZodString>;
+                            raw: z.ZodOptional<z.ZodString>;
+                            url: z.ZodOptional<z.ZodString>;
+                            data: z.ZodOptional<z.ZodUnknown>;
+                            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                            filename: z.ZodOptional<z.ZodString>;
+                            mediaType: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strip>>;
+                        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    }, z.core.$strip>>>;
+                    history: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        messageId: z.ZodString;
+                        contextId: z.ZodOptional<z.ZodString>;
+                        taskId: z.ZodOptional<z.ZodString>;
+                        role: z.ZodEnum<{
+                            ROLE_USER: "ROLE_USER";
+                            ROLE_AGENT: "ROLE_AGENT";
+                        }>;
+                        parts: z.ZodArray<z.ZodObject<{
+                            text: z.ZodOptional<z.ZodString>;
+                            raw: z.ZodOptional<z.ZodString>;
+                            url: z.ZodOptional<z.ZodString>;
+                            data: z.ZodOptional<z.ZodUnknown>;
+                            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                            filename: z.ZodOptional<z.ZodString>;
+                            mediaType: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strip>>;
+                        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        referenceTaskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    }, z.core.$strip>>>;
+                    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    id: z.ZodString;
+                }, z.core.$strip>;
+                role: z.ZodEnum<{
+                    requester: "requester";
+                    executor: "executor";
+                }>;
+                key: z.ZodString;
+                peer: z.ZodObject<{
+                    address: z.ZodString;
+                    person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+                    agent: z.ZodOptional<z.ZodString>;
+                    device: z.ZodString;
+                    label: z.ZodString;
+                }, z.core.$strip>;
+                createdAt: z.ZodNumber;
+                updatedAt: z.ZodNumber;
+                chain: z.ZodOptional<z.ZodObject<{
+                    addresses: z.ZodArray<z.ZodString>;
+                    depth: z.ZodNumber;
+                    maxDepth: z.ZodNumber;
+                    scope: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    exp: z.ZodNumber;
+                }, z.core.$strip>>;
+                followUps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    envelopeId: z.ZodString;
+                    messageId: z.ZodString;
+                    sentAt: z.ZodNumber;
+                    stage: z.ZodEnum<{
+                        accepted: "accepted";
+                        relayed: "relayed";
+                        delivered: "delivered";
+                        held: "held";
+                        handed_to_agent: "handed_to_agent";
+                        read: "read";
+                        replied: "replied";
+                        rejected: "rejected";
+                        expired: "expired";
+                    }>;
+                    at: z.ZodNumber;
+                }, z.core.$strip>>>;
+            }, z.core.$strip>>;
+            nextCursor: z.ZodOptional<z.ZodString>;
+            total: z.ZodNumber;
+        }, z.core.$strip>;
+    };
+    readonly "task.get": {
+        readonly params: z.ZodObject<{
+            key: z.ZodString;
+            taskId: z.ZodString;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            task: z.ZodObject<{
+                contextId: z.ZodOptional<z.ZodString>;
+                status: z.ZodObject<{
+                    state: z.ZodEnum<{
+                        TASK_STATE_SUBMITTED: "TASK_STATE_SUBMITTED";
+                        TASK_STATE_WORKING: "TASK_STATE_WORKING";
+                        TASK_STATE_COMPLETED: "TASK_STATE_COMPLETED";
+                        TASK_STATE_FAILED: "TASK_STATE_FAILED";
+                        TASK_STATE_CANCELED: "TASK_STATE_CANCELED";
+                        TASK_STATE_INPUT_REQUIRED: "TASK_STATE_INPUT_REQUIRED";
+                        TASK_STATE_REJECTED: "TASK_STATE_REJECTED";
+                        TASK_STATE_AUTH_REQUIRED: "TASK_STATE_AUTH_REQUIRED";
+                    }>;
+                    message: z.ZodOptional<z.ZodObject<{
+                        messageId: z.ZodString;
+                        contextId: z.ZodOptional<z.ZodString>;
+                        taskId: z.ZodOptional<z.ZodString>;
+                        role: z.ZodEnum<{
+                            ROLE_USER: "ROLE_USER";
+                            ROLE_AGENT: "ROLE_AGENT";
+                        }>;
+                        parts: z.ZodArray<z.ZodObject<{
+                            text: z.ZodOptional<z.ZodString>;
+                            raw: z.ZodOptional<z.ZodString>;
+                            url: z.ZodOptional<z.ZodString>;
+                            data: z.ZodOptional<z.ZodUnknown>;
+                            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                            filename: z.ZodOptional<z.ZodString>;
+                            mediaType: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strip>>;
+                        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        referenceTaskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    }, z.core.$strip>>;
+                    timestamp: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                artifacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    artifactId: z.ZodString;
+                    name: z.ZodOptional<z.ZodString>;
+                    description: z.ZodOptional<z.ZodString>;
+                    parts: z.ZodArray<z.ZodObject<{
+                        text: z.ZodOptional<z.ZodString>;
+                        raw: z.ZodOptional<z.ZodString>;
+                        url: z.ZodOptional<z.ZodString>;
+                        data: z.ZodOptional<z.ZodUnknown>;
+                        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        filename: z.ZodOptional<z.ZodString>;
+                        mediaType: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>>;
+                history: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    messageId: z.ZodString;
+                    contextId: z.ZodOptional<z.ZodString>;
+                    taskId: z.ZodOptional<z.ZodString>;
+                    role: z.ZodEnum<{
+                        ROLE_USER: "ROLE_USER";
+                        ROLE_AGENT: "ROLE_AGENT";
+                    }>;
+                    parts: z.ZodArray<z.ZodObject<{
+                        text: z.ZodOptional<z.ZodString>;
+                        raw: z.ZodOptional<z.ZodString>;
+                        url: z.ZodOptional<z.ZodString>;
+                        data: z.ZodOptional<z.ZodUnknown>;
+                        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        filename: z.ZodOptional<z.ZodString>;
+                        mediaType: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    referenceTaskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>>;
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                id: z.ZodString;
+            }, z.core.$strip>;
+            role: z.ZodEnum<{
+                requester: "requester";
+                executor: "executor";
+            }>;
+            key: z.ZodString;
+            peer: z.ZodObject<{
+                address: z.ZodString;
+                person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+                agent: z.ZodOptional<z.ZodString>;
+                device: z.ZodString;
+                label: z.ZodString;
+            }, z.core.$strip>;
+            createdAt: z.ZodNumber;
+            updatedAt: z.ZodNumber;
+            chain: z.ZodOptional<z.ZodObject<{
+                addresses: z.ZodArray<z.ZodString>;
+                depth: z.ZodNumber;
+                maxDepth: z.ZodNumber;
+                scope: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                exp: z.ZodNumber;
+            }, z.core.$strip>>;
+            followUps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                envelopeId: z.ZodString;
+                messageId: z.ZodString;
+                sentAt: z.ZodNumber;
+                stage: z.ZodEnum<{
+                    accepted: "accepted";
+                    relayed: "relayed";
+                    delivered: "delivered";
+                    held: "held";
+                    handed_to_agent: "handed_to_agent";
+                    read: "read";
+                    replied: "replied";
+                    rejected: "rejected";
+                    expired: "expired";
+                }>;
+                at: z.ZodNumber;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+    };
+    readonly "task.update": {
+        readonly params: z.ZodObject<{
+            key: z.ZodString;
+            taskId: z.ZodString;
+            state: z.ZodEnum<{
+                TASK_STATE_SUBMITTED: "TASK_STATE_SUBMITTED";
+                TASK_STATE_WORKING: "TASK_STATE_WORKING";
+                TASK_STATE_COMPLETED: "TASK_STATE_COMPLETED";
+                TASK_STATE_FAILED: "TASK_STATE_FAILED";
+                TASK_STATE_CANCELED: "TASK_STATE_CANCELED";
+                TASK_STATE_INPUT_REQUIRED: "TASK_STATE_INPUT_REQUIRED";
+                TASK_STATE_REJECTED: "TASK_STATE_REJECTED";
+                TASK_STATE_AUTH_REQUIRED: "TASK_STATE_AUTH_REQUIRED";
+            }>;
+            message: z.ZodOptional<z.ZodObject<{
+                parts: z.ZodArray<z.ZodObject<{
+                    text: z.ZodOptional<z.ZodString>;
+                    raw: z.ZodOptional<z.ZodString>;
+                    url: z.ZodOptional<z.ZodString>;
+                    data: z.ZodOptional<z.ZodUnknown>;
+                    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    filename: z.ZodOptional<z.ZodString>;
+                    mediaType: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+            }, z.core.$strict>>;
+            artifact: z.ZodOptional<z.ZodObject<{
+                artifactId: z.ZodString;
+                name: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+                parts: z.ZodArray<z.ZodObject<{
+                    text: z.ZodOptional<z.ZodString>;
+                    raw: z.ZodOptional<z.ZodString>;
+                    url: z.ZodOptional<z.ZodString>;
+                    data: z.ZodOptional<z.ZodUnknown>;
+                    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    filename: z.ZodOptional<z.ZodString>;
+                    mediaType: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            append: z.ZodOptional<z.ZodBoolean>;
+            lastChunk: z.ZodOptional<z.ZodBoolean>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            task: z.ZodObject<{
+                contextId: z.ZodOptional<z.ZodString>;
+                status: z.ZodObject<{
+                    state: z.ZodEnum<{
+                        TASK_STATE_SUBMITTED: "TASK_STATE_SUBMITTED";
+                        TASK_STATE_WORKING: "TASK_STATE_WORKING";
+                        TASK_STATE_COMPLETED: "TASK_STATE_COMPLETED";
+                        TASK_STATE_FAILED: "TASK_STATE_FAILED";
+                        TASK_STATE_CANCELED: "TASK_STATE_CANCELED";
+                        TASK_STATE_INPUT_REQUIRED: "TASK_STATE_INPUT_REQUIRED";
+                        TASK_STATE_REJECTED: "TASK_STATE_REJECTED";
+                        TASK_STATE_AUTH_REQUIRED: "TASK_STATE_AUTH_REQUIRED";
+                    }>;
+                    message: z.ZodOptional<z.ZodObject<{
+                        messageId: z.ZodString;
+                        contextId: z.ZodOptional<z.ZodString>;
+                        taskId: z.ZodOptional<z.ZodString>;
+                        role: z.ZodEnum<{
+                            ROLE_USER: "ROLE_USER";
+                            ROLE_AGENT: "ROLE_AGENT";
+                        }>;
+                        parts: z.ZodArray<z.ZodObject<{
+                            text: z.ZodOptional<z.ZodString>;
+                            raw: z.ZodOptional<z.ZodString>;
+                            url: z.ZodOptional<z.ZodString>;
+                            data: z.ZodOptional<z.ZodUnknown>;
+                            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                            filename: z.ZodOptional<z.ZodString>;
+                            mediaType: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strip>>;
+                        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        referenceTaskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    }, z.core.$strip>>;
+                    timestamp: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                artifacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    artifactId: z.ZodString;
+                    name: z.ZodOptional<z.ZodString>;
+                    description: z.ZodOptional<z.ZodString>;
+                    parts: z.ZodArray<z.ZodObject<{
+                        text: z.ZodOptional<z.ZodString>;
+                        raw: z.ZodOptional<z.ZodString>;
+                        url: z.ZodOptional<z.ZodString>;
+                        data: z.ZodOptional<z.ZodUnknown>;
+                        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        filename: z.ZodOptional<z.ZodString>;
+                        mediaType: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>>;
+                history: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    messageId: z.ZodString;
+                    contextId: z.ZodOptional<z.ZodString>;
+                    taskId: z.ZodOptional<z.ZodString>;
+                    role: z.ZodEnum<{
+                        ROLE_USER: "ROLE_USER";
+                        ROLE_AGENT: "ROLE_AGENT";
+                    }>;
+                    parts: z.ZodArray<z.ZodObject<{
+                        text: z.ZodOptional<z.ZodString>;
+                        raw: z.ZodOptional<z.ZodString>;
+                        url: z.ZodOptional<z.ZodString>;
+                        data: z.ZodOptional<z.ZodUnknown>;
+                        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        filename: z.ZodOptional<z.ZodString>;
+                        mediaType: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    referenceTaskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>>;
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                id: z.ZodString;
+            }, z.core.$strip>;
+            role: z.ZodEnum<{
+                requester: "requester";
+                executor: "executor";
+            }>;
+            key: z.ZodString;
+            peer: z.ZodObject<{
+                address: z.ZodString;
+                person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+                agent: z.ZodOptional<z.ZodString>;
+                device: z.ZodString;
+                label: z.ZodString;
+            }, z.core.$strip>;
+            createdAt: z.ZodNumber;
+            updatedAt: z.ZodNumber;
+            chain: z.ZodOptional<z.ZodObject<{
+                addresses: z.ZodArray<z.ZodString>;
+                depth: z.ZodNumber;
+                maxDepth: z.ZodNumber;
+                scope: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                exp: z.ZodNumber;
+            }, z.core.$strip>>;
+            followUps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                envelopeId: z.ZodString;
+                messageId: z.ZodString;
+                sentAt: z.ZodNumber;
+                stage: z.ZodEnum<{
+                    accepted: "accepted";
+                    relayed: "relayed";
+                    delivered: "delivered";
+                    held: "held";
+                    handed_to_agent: "handed_to_agent";
+                    read: "read";
+                    replied: "replied";
+                    rejected: "rejected";
+                    expired: "expired";
+                }>;
+                at: z.ZodNumber;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+    };
+    readonly "task.cancel": {
+        readonly params: z.ZodObject<{
+            key: z.ZodString;
+            taskId: z.ZodString;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            task: z.ZodObject<{
+                contextId: z.ZodOptional<z.ZodString>;
+                status: z.ZodObject<{
+                    state: z.ZodEnum<{
+                        TASK_STATE_SUBMITTED: "TASK_STATE_SUBMITTED";
+                        TASK_STATE_WORKING: "TASK_STATE_WORKING";
+                        TASK_STATE_COMPLETED: "TASK_STATE_COMPLETED";
+                        TASK_STATE_FAILED: "TASK_STATE_FAILED";
+                        TASK_STATE_CANCELED: "TASK_STATE_CANCELED";
+                        TASK_STATE_INPUT_REQUIRED: "TASK_STATE_INPUT_REQUIRED";
+                        TASK_STATE_REJECTED: "TASK_STATE_REJECTED";
+                        TASK_STATE_AUTH_REQUIRED: "TASK_STATE_AUTH_REQUIRED";
+                    }>;
+                    message: z.ZodOptional<z.ZodObject<{
+                        messageId: z.ZodString;
+                        contextId: z.ZodOptional<z.ZodString>;
+                        taskId: z.ZodOptional<z.ZodString>;
+                        role: z.ZodEnum<{
+                            ROLE_USER: "ROLE_USER";
+                            ROLE_AGENT: "ROLE_AGENT";
+                        }>;
+                        parts: z.ZodArray<z.ZodObject<{
+                            text: z.ZodOptional<z.ZodString>;
+                            raw: z.ZodOptional<z.ZodString>;
+                            url: z.ZodOptional<z.ZodString>;
+                            data: z.ZodOptional<z.ZodUnknown>;
+                            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                            filename: z.ZodOptional<z.ZodString>;
+                            mediaType: z.ZodOptional<z.ZodString>;
+                        }, z.core.$strip>>;
+                        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                        referenceTaskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    }, z.core.$strip>>;
+                    timestamp: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                artifacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    artifactId: z.ZodString;
+                    name: z.ZodOptional<z.ZodString>;
+                    description: z.ZodOptional<z.ZodString>;
+                    parts: z.ZodArray<z.ZodObject<{
+                        text: z.ZodOptional<z.ZodString>;
+                        raw: z.ZodOptional<z.ZodString>;
+                        url: z.ZodOptional<z.ZodString>;
+                        data: z.ZodOptional<z.ZodUnknown>;
+                        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        filename: z.ZodOptional<z.ZodString>;
+                        mediaType: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>>;
+                history: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    messageId: z.ZodString;
+                    contextId: z.ZodOptional<z.ZodString>;
+                    taskId: z.ZodOptional<z.ZodString>;
+                    role: z.ZodEnum<{
+                        ROLE_USER: "ROLE_USER";
+                        ROLE_AGENT: "ROLE_AGENT";
+                    }>;
+                    parts: z.ZodArray<z.ZodObject<{
+                        text: z.ZodOptional<z.ZodString>;
+                        raw: z.ZodOptional<z.ZodString>;
+                        url: z.ZodOptional<z.ZodString>;
+                        data: z.ZodOptional<z.ZodUnknown>;
+                        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        filename: z.ZodOptional<z.ZodString>;
+                        mediaType: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    referenceTaskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>>;
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                id: z.ZodString;
+            }, z.core.$strip>;
+            role: z.ZodEnum<{
+                requester: "requester";
+                executor: "executor";
+            }>;
+            key: z.ZodString;
+            peer: z.ZodObject<{
+                address: z.ZodString;
+                person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+                agent: z.ZodOptional<z.ZodString>;
+                device: z.ZodString;
+                label: z.ZodString;
+            }, z.core.$strip>;
+            createdAt: z.ZodNumber;
+            updatedAt: z.ZodNumber;
+            chain: z.ZodOptional<z.ZodObject<{
+                addresses: z.ZodArray<z.ZodString>;
+                depth: z.ZodNumber;
+                maxDepth: z.ZodNumber;
+                scope: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                exp: z.ZodNumber;
+            }, z.core.$strip>>;
+            followUps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                envelopeId: z.ZodString;
+                messageId: z.ZodString;
+                sentAt: z.ZodNumber;
+                stage: z.ZodEnum<{
+                    accepted: "accepted";
+                    relayed: "relayed";
+                    delivered: "delivered";
+                    held: "held";
+                    handed_to_agent: "handed_to_agent";
+                    read: "read";
+                    replied: "replied";
+                    rejected: "rejected";
+                    expired: "expired";
+                }>;
+                at: z.ZodNumber;
+            }, z.core.$strip>>>;
+        }, z.core.$strip>;
+    };
+    readonly "events.subscribe": {
+        readonly params: z.ZodObject<{
+            keys: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+    };
+    readonly "team.create": {
+        readonly params: z.ZodObject<{
+            name: z.ZodString;
+            person: z.ZodString;
+            label: z.ZodString;
+            relay: z.ZodString;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            team: z.ZodString;
+            name: z.ZodString;
+            machine: z.ZodString;
+        }, z.core.$strip>;
+    };
+    readonly "team.invite": {
+        readonly params: z.ZodObject<{
+            person: z.ZodString;
+            ttlMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            ticket: z.ZodString;
+            inviteId: z.ZodString;
+            expires: z.ZodNumber;
+        }, z.core.$strip>;
+    };
+    readonly "team.join": {
+        readonly params: z.ZodObject<{
+            ticket: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            team: z.ZodString;
+            name: z.ZodString;
+            machine: z.ZodString;
+            person: z.ZodString;
+        }, z.core.$strip>;
+    };
+    readonly "team.members": {
+        readonly params: z.ZodObject<{}, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            team: z.ZodObject<{
+                id: z.ZodString;
+                name: z.ZodString;
+            }, z.core.$strip>;
+            members: z.ZodArray<z.ZodObject<{
+                machine: z.ZodString;
+                enc: z.ZodString;
+                person: z.ZodString;
+                role: z.ZodEnum<{
+                    admin: "admin";
+                    member: "member";
+                }>;
+                label: z.ZodString;
+                self: z.ZodBoolean;
+                online: z.ZodBoolean;
+            }, z.core.$strip>>;
+            invites: z.ZodArray<z.ZodObject<{
+                inviteId: z.ZodString;
+                person: z.ZodString;
+                expires: z.ZodNumber;
+                state: z.ZodEnum<{
+                    expired: "expired";
+                    open: "open";
+                    redeemed: "redeemed";
+                    revoked: "revoked";
+                }>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    readonly "team.remove": {
+        readonly params: z.ZodObject<{
+            machine: z.ZodString;
+            reason: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+    };
+    readonly "team.role": {
+        readonly params: z.ZodObject<{
+            machine: z.ZodString;
+            role: z.ZodEnum<{
+                admin: "admin";
+                member: "member";
+            }>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+    };
+    readonly "team.revokeInvite": {
+        readonly params: z.ZodObject<{
+            inviteId: z.ZodString;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+    };
+    /**
+     * Rotates this machine's encryption key (spec §4 `member.rekey`, §8.2). Returns the new public key
+     * and when the previous one is dropped. Never a private key.
+     */
+    readonly "identity.rotateEnc": {
+        readonly params: z.ZodObject<{}, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            enc: z.ZodString;
+            until: z.ZodNumber;
+        }, z.core.$strip>;
+    };
+    /**
+     * Admin admits a machine by the public keys it showed. No invite seed. The joiner connects only after
+     * this entry is on the roster (spec §4 `member.add`, §8.2).
+     */
+    readonly "team.add": {
+        readonly params: z.ZodObject<{
+            machine: z.ZodString;
+            enc: z.ZodString;
+            person: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+    };
+    /**
+     * Joiner: generate keys and store them aside from `identity.json`, so the plugin does not treat the
+     * machine as joined. Returns the public admit card. Private keys stay in the daemon.
+     */
+    readonly "team.pair": {
+        readonly params: z.ZodObject<{
+            relay: z.ZodString;
+            team: z.ZodString;
+            person: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            machine: z.ZodString;
+            enc: z.ZodString;
+            person: z.ZodString;
+            label: z.ZodString;
+            admit: z.ZodString;
+        }, z.core.$strip>;
+    };
+    /**
+     * Joiner: try hello with the paired keys. `waiting` means the admin has not admitted this machine yet.
+     * `joined` means the roster names these exact keys, person and label, and the daemon has adopted them.
+     */
+    readonly "team.claim": {
+        readonly params: z.ZodObject<{
+            waitMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        readonly result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            state: z.ZodLiteral<"waiting">;
+        }, z.core.$strip>, z.ZodObject<{
+            state: z.ZodLiteral<"joined">;
+            team: z.ZodString;
+            name: z.ZodString;
+            machine: z.ZodString;
+            person: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strip>], "state">;
+    };
+    /** Discard pending keys (a pairing or founding keys), including their private keys. */
+    readonly "team.pairCancel": {
+        readonly params: z.ZodObject<{}, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+    };
+    /**
+     * Founder: generate the keys `team.create` will use and store them aside from `identity.json`, so a
+     * relay operator can list the machine id in `--allow-team-create` first. Returns the same public keys
+     * while they are pending. Private keys stay in the daemon.
+     */
+    readonly "team.prepare": {
+        readonly params: z.ZodObject<{}, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            machine: z.ZodString;
+            enc: z.ZodString;
+        }, z.core.$strip>;
+    };
+    /** Creates a channel with this person and `persons` (at most `LIMITS.channelPersons` together). */
+    readonly "channel.create": {
+        readonly params: z.ZodObject<{
+            name: z.ZodString;
+            persons: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            id: z.ZodString;
+            name: z.ZodString;
+        }, z.core.$strip>;
+    };
+    readonly "channel.invite": {
+        readonly params: z.ZodObject<{
+            name: z.ZodString;
+            persons: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+    };
+    readonly "channel.leave": {
+        readonly params: z.ZodObject<{
+            name: z.ZodString;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+    };
+    /** Removes other persons from a channel; only its creator or a team admin may (spec §6.8). */
+    readonly "channel.remove": {
+        readonly params: z.ZodObject<{
+            name: z.ZodString;
+            persons: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+    };
+    readonly "device.status": {
+        readonly params: z.ZodObject<{}, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            realm: z.ZodEnum<{
+                roster: "roster";
+                directory: "directory";
+            }>;
+            device: z.ZodOptional<z.ZodString>;
+            binding: z.ZodEnum<{
+                removed: "removed";
+                none: "none";
+                bound: "bound";
+                "attest-due": "attest-due";
+                replace: "replace";
+            }>;
+            person: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+            label: z.ZodOptional<z.ZodString>;
+            sth: z.ZodOptional<z.ZodObject<{
+                size: z.ZodNumber;
+                root: z.ZodString;
+                ts: z.ZodNumber;
+            }, z.core.$strip>>;
+            alarm: z.ZodOptional<z.ZodObject<{
+                kind: z.ZodEnum<{
+                    directory: "directory";
+                    restored: "restored";
+                }>;
+                reason: z.ZodString;
+                at: z.ZodNumber;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    readonly "device.bind": {
+        readonly params: z.ZodObject<{
+            token: z.ZodString;
+            label: z.ZodOptional<z.ZodString>;
+            kind: z.ZodOptional<z.ZodEnum<{
+                "jelly-host": "jelly-host";
+                laptop: "laptop";
+                server: "server";
+                other: "other";
+            }>>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+            device: z.ZodString;
+            seq: z.ZodNumber;
+        }, z.core.$strip>;
+    };
+    readonly "device.list": {
+        readonly params: z.ZodObject<{}, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            devices: z.ZodArray<z.ZodObject<{
+                device: z.ZodString;
+                label: z.ZodString;
+                kind: z.ZodOptional<z.ZodEnum<{
+                    "jelly-host": "jelly-host";
+                    laptop: "laptop";
+                    server: "server";
+                    other: "other";
+                }>>;
+                vouched: z.ZodEnum<{
+                    admin: "admin";
+                    device: "device";
+                    jelly: "jelly";
+                }>;
+                via: z.ZodOptional<z.ZodEnum<{
+                    host: "host";
+                    browser: "browser";
+                }>>;
+                current: z.ZodBoolean;
+                self: z.ZodBoolean;
+                since: z.ZodOptional<z.ZodNumber>;
+                unbound: z.ZodOptional<z.ZodObject<{
+                    at: z.ZodNumber;
+                    reason: z.ZodEnum<{
+                        self: "self";
+                        removed: "removed";
+                        lost: "lost";
+                        replaced: "replaced";
+                        account_deleted: "account_deleted";
+                    }>;
+                    by: z.ZodString;
+                }, z.core.$strip>>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+    };
+    readonly "device.remove": {
+        readonly params: z.ZodObject<{
+            device: z.ZodString;
+            reason: z.ZodOptional<z.ZodEnum<{
+                self: "self";
+                removed: "removed";
+                lost: "lost";
+            }>>;
+            token: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            seq: z.ZodNumber;
+        }, z.core.$strip>;
+    };
+    readonly "device.link": {
+        readonly params: z.ZodObject<{
+            label: z.ZodOptional<z.ZodString>;
+            kind: z.ZodOptional<z.ZodEnum<{
+                "jelly-host": "jelly-host";
+                laptop: "laptop";
+                server: "server";
+                other: "other";
+            }>>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            link: z.ZodString;
+            sas: z.ZodString;
+            expires: z.ZodNumber;
+        }, z.core.$strip>;
+    };
+    readonly "device.login": {
+        readonly params: z.ZodObject<{
+            label: z.ZodOptional<z.ZodString>;
+            kind: z.ZodOptional<z.ZodEnum<{
+                laptop: "laptop";
+                server: "server";
+                other: "other";
+            }>>;
+            remove: z.ZodOptional<z.ZodObject<{
+                device: z.ZodString;
+                reason: z.ZodOptional<z.ZodEnum<{
+                    removed: "removed";
+                    lost: "lost";
+                }>>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            verificationUri: z.ZodString;
+            userCode: z.ZodString;
+            fingerprint: z.ZodString;
+            expires: z.ZodNumber;
+            purpose: z.ZodEnum<{
+                bind: "bind";
+                replace: "replace";
+                remove: "remove";
+                erase: "erase";
+            }>;
+            interval: z.ZodNumber;
+        }, z.core.$strip>;
+    };
+    readonly "device.login.status": {
+        readonly params: z.ZodObject<{
+            waitMs: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        readonly result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            state: z.ZodLiteral<"idle">;
+        }, z.core.$strip>, z.ZodObject<{
+            verificationUri: z.ZodString;
+            userCode: z.ZodString;
+            fingerprint: z.ZodString;
+            expires: z.ZodNumber;
+            state: z.ZodLiteral<"pending">;
+            purpose: z.ZodEnum<{
+                bind: "bind";
+                replace: "replace";
+                remove: "remove";
+                erase: "erase";
+            }>;
+        }, z.core.$strip>, z.ZodObject<{
+            state: z.ZodLiteral<"done">;
+            purpose: z.ZodEnum<{
+                bind: "bind";
+                replace: "replace";
+                remove: "remove";
+                erase: "erase";
+            }>;
+            person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+            device: z.ZodString;
+            seq: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            state: z.ZodLiteral<"failed">;
+            purpose: z.ZodEnum<{
+                bind: "bind";
+                replace: "replace";
+                remove: "remove";
+                erase: "erase";
+            }>;
+            code: z.ZodEnum<{
+                expired: "expired";
+                invalid_request: "invalid_request";
+                not_member: "not_member";
+                bad_signature: "bad_signature";
+                unknown_session: "unknown_session";
+                ambiguous_address: "ambiguous_address";
+                no_recipients: "no_recipients";
+                unknown_address: "unknown_address";
+                refused: "refused";
+                declined: "declined";
+                request_required: "request_required";
+                rate_limited: "rate_limited";
+                loop_guard: "loop_guard";
+                too_large: "too_large";
+                secret_refused: "secret_refused";
+                duplicate: "duplicate";
+                relay_unavailable: "relay_unavailable";
+                not_found: "not_found";
+                invalid_state: "invalid_state";
+                forbidden: "forbidden";
+                guarded_turn: "guarded_turn";
+                roster_conflict: "roster_conflict";
+                invite_invalid: "invite_invalid";
+                no_identity: "no_identity";
+                binding_invalid: "binding_invalid";
+                jelly_unavailable: "jelly_unavailable";
+                log_conflict: "log_conflict";
+                conv_conflict: "conv_conflict";
+                stale_epoch: "stale_epoch";
+                device_limit: "device_limit";
+                admission_required: "admission_required";
+                admission_invalid: "admission_invalid";
+                directory_inconsistent: "directory_inconsistent";
+                unknown_device: "unknown_device";
+                directory_unavailable: "directory_unavailable";
+                login_unsupported: "login_unsupported";
+                login_denied: "login_denied";
+                grant_required: "grant_required";
+                grant_invalid: "grant_invalid";
+                ticket_required: "ticket_required";
+                ticket_invalid: "ticket_invalid";
+                daemon_unavailable: "daemon_unavailable";
+                daemon_mismatch: "daemon_mismatch";
+                store_refused: "store_refused";
+                internal: "internal";
+            }>;
+            message: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            state: z.ZodLiteral<"cancelled">;
+            purpose: z.ZodEnum<{
+                bind: "bind";
+                replace: "replace";
+                remove: "remove";
+                erase: "erase";
+            }>;
+        }, z.core.$strip>], "state">;
+    };
+    readonly "device.login.cancel": {
+        readonly params: z.ZodObject<{}, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+    };
+    readonly "device.approve.preview": {
+        readonly params: z.ZodObject<{
+            link: z.ZodString;
+            sas: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            device: z.ZodString;
+            label: z.ZodString;
+            kind: z.ZodEnum<{
+                "jelly-host": "jelly-host";
+                laptop: "laptop";
+                server: "server";
+                other: "other";
+            }>;
+            sas: z.ZodString;
+        }, z.core.$strip>;
+    };
+    readonly "device.approve": {
+        readonly params: z.ZodObject<{
+            link: z.ZodString;
+            sas: z.ZodString;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            device: z.ZodString;
+            seq: z.ZodNumber;
+        }, z.core.$strip>;
+    };
+    readonly "identity.replace": {
+        readonly params: z.ZodObject<{
+            token: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        readonly result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            state: z.ZodLiteral<"done">;
+            person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+            device: z.ZodString;
+            predecessor: z.ZodString;
+            seq: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            state: z.ZodLiteral<"token">;
+            device: z.ZodString;
+        }, z.core.$strip>, z.ZodObject<{
+            verificationUri: z.ZodString;
+            userCode: z.ZodString;
+            fingerprint: z.ZodString;
+            expires: z.ZodNumber;
+            state: z.ZodLiteral<"sign-in">;
+            purpose: z.ZodEnum<{
+                bind: "bind";
+                replace: "replace";
+                remove: "remove";
+                erase: "erase";
+            }>;
+            interval: z.ZodNumber;
+            device: z.ZodString;
+        }, z.core.$strip>], "state">;
+    };
+    readonly "identity.replace.preview": {
+        readonly params: z.ZodObject<{
+            token: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            predecessor: z.ZodObject<{
+                device: z.ZodString;
+                label: z.ZodString;
+                kind: z.ZodOptional<z.ZodEnum<{
+                    "jelly-host": "jelly-host";
+                    laptop: "laptop";
+                    server: "server";
+                    other: "other";
+                }>>;
+                vouch: z.ZodEnum<{
+                    device: "device";
+                    jelly: "jelly";
+                }>;
+                via: z.ZodOptional<z.ZodEnum<{
+                    host: "host";
+                    browser: "browser";
+                }>>;
+                since: z.ZodOptional<z.ZodNumber>;
+                current: z.ZodBoolean;
+            }, z.core.$strip>;
+            alarm: z.ZodNullable<z.ZodEnum<{
+                restored: "restored";
+                keys_missing: "keys_missing";
+            }>>;
+            device: z.ZodOptional<z.ZodString>;
+            signIns: z.ZodNumber;
+            sentence: z.ZodString;
+        }, z.core.$strip>;
+    };
+    readonly "directory.erase": {
+        readonly params: z.ZodObject<{
+            token: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        readonly result: z.ZodDiscriminatedUnion<[z.ZodObject<{
+            state: z.ZodLiteral<"done">;
+            person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+            devices: z.ZodNumber;
+        }, z.core.$strip>, z.ZodObject<{
+            verificationUri: z.ZodString;
+            userCode: z.ZodString;
+            fingerprint: z.ZodString;
+            expires: z.ZodNumber;
+            state: z.ZodLiteral<"sign-in">;
+            purpose: z.ZodEnum<{
+                bind: "bind";
+                replace: "replace";
+                remove: "remove";
+                erase: "erase";
+            }>;
+            interval: z.ZodNumber;
+        }, z.core.$strip>], "state">;
+    };
+    readonly "directory.erase.preview": {
+        readonly params: z.ZodObject<{
+            token: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+            devices: z.ZodArray<z.ZodObject<{
+                device: z.ZodString;
+                label: z.ZodString;
+                kind: z.ZodOptional<z.ZodEnum<{
+                    "jelly-host": "jelly-host";
+                    laptop: "laptop";
+                    server: "server";
+                    other: "other";
+                }>>;
+                self: z.ZodBoolean;
+            }, z.core.$strip>>;
+            signIns: z.ZodNumber;
+            perDay: z.ZodNumber;
+            lost: z.ZodArray<z.ZodString>;
+            kept: z.ZodArray<z.ZodString>;
+        }, z.core.$strip>;
+    };
+};
+export type IpcMethods = typeof IPC_METHODS;
+export type IpcMethod = keyof IpcMethods;
+export type IpcParams<M extends IpcMethod> = z.input<IpcMethods[M]["params"]>;
+export type IpcResult<M extends IpcMethod> = z.infer<IpcMethods[M]["result"]>;
+/**
+ * The agent tier (design §7.5): the methods an agent-facing client may call, and exactly what the
+ * daemon serves on `run/agent.sock` (spec §8.2). Anything else is for human clients, on
+ * `run/admin.sock`: the `messaging` CLI and the `/messaging` TUI.
+ */
+export declare const AGENT_METHODS: readonly ["daemon.status", "daemon.health", "device.status", "device.bind", "session.register", "session.update", "session.unregister", "events.subscribe", "contacts.list", "msg.send", "inbox.list", "inbox.get", "inbox.ack", "item.read", "conv.read", "search", "task.list", "task.get", "task.update", "task.cancel"];
+export type AgentMethod = (typeof AGENT_METHODS)[number];
+/**
+ * The human tier (design §7.5): methods that act as the person, on `run/admin.sock` only: their
+ * conversations and own lines, the people of the realm, their grants and held requests (spec §6.9), and channels.
+ * `conv.read` is in both tiers.
+ */
+export declare const HUMAN_METHODS: readonly ["conv.list", "conv.read", "conv.markRead", "conv.subscribe", "person.send", "people.search", "people.get", "grant.list", "grant.set", "grant.set.preview", "request.list", "request.answer", "request.answer.preview", "contact.request", "contact.request.preview", "card.get", "agents.list", "agents.read", "notice.subscribe", "notice.list", "notice.ack", "device.approve.preview", "device.remove.preview", "identity.replace.preview", "directory.erase.preview", "channel.create", "channel.invite", "channel.leave", "channel.remove"];
+export type HumanMethod = (typeof HUMAN_METHODS)[number];
+/**
+ * The admin tier (design §7.5): this device and the daemon, and in a roster realm the team, on
+ * `run/admin.sock` only.
+ */
+export declare const ADMIN_METHODS: readonly ["daemon.stop", "daemon.woke", "person.attached", "daemon.snapshot", "wake.arm", "wake.disarm", "device.list", "device.remove", "device.link", "device.login", "device.login.status", "device.login.cancel", "device.approve", "identity.rotateEnc", "identity.replace", "directory.erase", "team.create", "team.invite", "team.join", "team.members", "team.remove", "team.role", "team.revokeInvite", "team.add", "team.pair", "team.claim", "team.pairCancel", "team.prepare"];
+export type AdminMethod = (typeof ADMIN_METHODS)[number];
+/**
+ * What a host-scope action grant (`act: "host"`) allows in `deployment: "jelly"` (spec §8.11), and nothing else: the
+ * notice stream and its counts, `conv.list` with counts only, stopping the daemon, and telling it the host woke
+ * (`daemon.woke`) and whether the person is at it (`person.attached`), a backup of the home (`daemon.snapshot`), and its
+ * wake ticket (`wake.arm`, `wake.disarm`).
+ */
+export declare const HOST_SCOPE_METHODS: readonly ["notice.subscribe", "notice.list", "conv.list", "daemon.stop", "daemon.woke", "person.attached", "daemon.snapshot", "wake.arm", "wake.disarm"];
+export declare const IpcEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"inbox">;
+    key: z.ZodString;
+    item: z.ZodObject<{
+        id: z.ZodString;
+        key: z.ZodString;
+        from: z.ZodObject<{
+            address: z.ZodString;
+            person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+            agent: z.ZodOptional<z.ZodString>;
+            device: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strip>;
+        kind: z.ZodEnum<{
+            message: "message";
+            task: "task";
+        }>;
+        messageId: z.ZodString;
+        taskId: z.ZodOptional<z.ZodString>;
+        contextId: z.ZodOptional<z.ZodString>;
+        replyTo: z.ZodOptional<z.ZodString>;
+        receivedAt: z.ZodNumber;
+        stage: z.ZodEnum<{
+            delivered: "delivered";
+            handed_to_agent: "handed_to_agent";
+            read: "read";
+        }>;
+        bytes: z.ZodNumber;
+        preview: z.ZodString;
+        wake: z.ZodBoolean;
+        chain: z.ZodOptional<z.ZodObject<{
+            addresses: z.ZodArray<z.ZodString>;
+            depth: z.ZodNumber;
+            maxDepth: z.ZodNumber;
+            scope: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            exp: z.ZodNumber;
+        }, z.core.$strip>>;
+        consent: z.ZodOptional<z.ZodEnum<{
+            self: "self";
+            guarded: "guarded";
+            trusted: "trusted";
+        }>>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"receipt">;
+    key: z.ZodString;
+    envelopeId: z.ZodString;
+    to: z.ZodString;
+    stage: z.ZodEnum<{
+        accepted: "accepted";
+        relayed: "relayed";
+        delivered: "delivered";
+        held: "held";
+        handed_to_agent: "handed_to_agent";
+        read: "read";
+        replied: "replied";
+        rejected: "rejected";
+        expired: "expired";
+    }>;
+    code: z.ZodOptional<z.ZodEnum<{
+        expired: "expired";
+        invalid_request: "invalid_request";
+        not_member: "not_member";
+        bad_signature: "bad_signature";
+        unknown_session: "unknown_session";
+        ambiguous_address: "ambiguous_address";
+        no_recipients: "no_recipients";
+        unknown_address: "unknown_address";
+        refused: "refused";
+        declined: "declined";
+        request_required: "request_required";
+        rate_limited: "rate_limited";
+        loop_guard: "loop_guard";
+        too_large: "too_large";
+        secret_refused: "secret_refused";
+        duplicate: "duplicate";
+        relay_unavailable: "relay_unavailable";
+        not_found: "not_found";
+        invalid_state: "invalid_state";
+        forbidden: "forbidden";
+        guarded_turn: "guarded_turn";
+        roster_conflict: "roster_conflict";
+        invite_invalid: "invite_invalid";
+        no_identity: "no_identity";
+        binding_invalid: "binding_invalid";
+        jelly_unavailable: "jelly_unavailable";
+        log_conflict: "log_conflict";
+        conv_conflict: "conv_conflict";
+        stale_epoch: "stale_epoch";
+        device_limit: "device_limit";
+        admission_required: "admission_required";
+        admission_invalid: "admission_invalid";
+        directory_inconsistent: "directory_inconsistent";
+        unknown_device: "unknown_device";
+        directory_unavailable: "directory_unavailable";
+        login_unsupported: "login_unsupported";
+        login_denied: "login_denied";
+        grant_required: "grant_required";
+        grant_invalid: "grant_invalid";
+        ticket_required: "ticket_required";
+        ticket_invalid: "ticket_invalid";
+        daemon_unavailable: "daemon_unavailable";
+        daemon_mismatch: "daemon_mismatch";
+        store_refused: "store_refused";
+        internal: "internal";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"task">;
+    key: z.ZodString;
+    record: z.ZodObject<{
+        task: z.ZodObject<{
+            contextId: z.ZodOptional<z.ZodString>;
+            status: z.ZodObject<{
+                state: z.ZodEnum<{
+                    TASK_STATE_SUBMITTED: "TASK_STATE_SUBMITTED";
+                    TASK_STATE_WORKING: "TASK_STATE_WORKING";
+                    TASK_STATE_COMPLETED: "TASK_STATE_COMPLETED";
+                    TASK_STATE_FAILED: "TASK_STATE_FAILED";
+                    TASK_STATE_CANCELED: "TASK_STATE_CANCELED";
+                    TASK_STATE_INPUT_REQUIRED: "TASK_STATE_INPUT_REQUIRED";
+                    TASK_STATE_REJECTED: "TASK_STATE_REJECTED";
+                    TASK_STATE_AUTH_REQUIRED: "TASK_STATE_AUTH_REQUIRED";
+                }>;
+                message: z.ZodOptional<z.ZodObject<{
+                    messageId: z.ZodString;
+                    contextId: z.ZodOptional<z.ZodString>;
+                    taskId: z.ZodOptional<z.ZodString>;
+                    role: z.ZodEnum<{
+                        ROLE_USER: "ROLE_USER";
+                        ROLE_AGENT: "ROLE_AGENT";
+                    }>;
+                    parts: z.ZodArray<z.ZodObject<{
+                        text: z.ZodOptional<z.ZodString>;
+                        raw: z.ZodOptional<z.ZodString>;
+                        url: z.ZodOptional<z.ZodString>;
+                        data: z.ZodOptional<z.ZodUnknown>;
+                        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                        filename: z.ZodOptional<z.ZodString>;
+                        mediaType: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                    referenceTaskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                }, z.core.$strip>>;
+                timestamp: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>;
+            artifacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                artifactId: z.ZodString;
+                name: z.ZodOptional<z.ZodString>;
+                description: z.ZodOptional<z.ZodString>;
+                parts: z.ZodArray<z.ZodObject<{
+                    text: z.ZodOptional<z.ZodString>;
+                    raw: z.ZodOptional<z.ZodString>;
+                    url: z.ZodOptional<z.ZodString>;
+                    data: z.ZodOptional<z.ZodUnknown>;
+                    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    filename: z.ZodOptional<z.ZodString>;
+                    mediaType: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>>;
+            history: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                messageId: z.ZodString;
+                contextId: z.ZodOptional<z.ZodString>;
+                taskId: z.ZodOptional<z.ZodString>;
+                role: z.ZodEnum<{
+                    ROLE_USER: "ROLE_USER";
+                    ROLE_AGENT: "ROLE_AGENT";
+                }>;
+                parts: z.ZodArray<z.ZodObject<{
+                    text: z.ZodOptional<z.ZodString>;
+                    raw: z.ZodOptional<z.ZodString>;
+                    url: z.ZodOptional<z.ZodString>;
+                    data: z.ZodOptional<z.ZodUnknown>;
+                    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    filename: z.ZodOptional<z.ZodString>;
+                    mediaType: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                referenceTaskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            id: z.ZodString;
+        }, z.core.$strip>;
+        role: z.ZodEnum<{
+            requester: "requester";
+            executor: "executor";
+        }>;
+        key: z.ZodString;
+        peer: z.ZodObject<{
+            address: z.ZodString;
+            person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+            agent: z.ZodOptional<z.ZodString>;
+            device: z.ZodString;
+            label: z.ZodString;
+        }, z.core.$strip>;
+        createdAt: z.ZodNumber;
+        updatedAt: z.ZodNumber;
+        chain: z.ZodOptional<z.ZodObject<{
+            addresses: z.ZodArray<z.ZodString>;
+            depth: z.ZodNumber;
+            maxDepth: z.ZodNumber;
+            scope: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            exp: z.ZodNumber;
+        }, z.core.$strip>>;
+        followUps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            envelopeId: z.ZodString;
+            messageId: z.ZodString;
+            sentAt: z.ZodNumber;
+            stage: z.ZodEnum<{
+                accepted: "accepted";
+                relayed: "relayed";
+                delivered: "delivered";
+                held: "held";
+                handed_to_agent: "handed_to_agent";
+                read: "read";
+                replied: "replied";
+                rejected: "rejected";
+                expired: "expired";
+            }>;
+            at: z.ZodNumber;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>;
+    origin: z.ZodEnum<{
+        peer: "peer";
+        local: "local";
+    }>;
+    update: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
+        status: z.ZodObject<{
+            state: z.ZodEnum<{
+                TASK_STATE_SUBMITTED: "TASK_STATE_SUBMITTED";
+                TASK_STATE_WORKING: "TASK_STATE_WORKING";
+                TASK_STATE_COMPLETED: "TASK_STATE_COMPLETED";
+                TASK_STATE_FAILED: "TASK_STATE_FAILED";
+                TASK_STATE_CANCELED: "TASK_STATE_CANCELED";
+                TASK_STATE_INPUT_REQUIRED: "TASK_STATE_INPUT_REQUIRED";
+                TASK_STATE_REJECTED: "TASK_STATE_REJECTED";
+                TASK_STATE_AUTH_REQUIRED: "TASK_STATE_AUTH_REQUIRED";
+            }>;
+            message: z.ZodOptional<z.ZodObject<{
+                messageId: z.ZodString;
+                contextId: z.ZodOptional<z.ZodString>;
+                taskId: z.ZodOptional<z.ZodString>;
+                role: z.ZodEnum<{
+                    ROLE_USER: "ROLE_USER";
+                    ROLE_AGENT: "ROLE_AGENT";
+                }>;
+                parts: z.ZodArray<z.ZodObject<{
+                    text: z.ZodOptional<z.ZodString>;
+                    raw: z.ZodOptional<z.ZodString>;
+                    url: z.ZodOptional<z.ZodString>;
+                    data: z.ZodOptional<z.ZodUnknown>;
+                    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    filename: z.ZodOptional<z.ZodString>;
+                    mediaType: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                referenceTaskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            timestamp: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+    }, z.core.$strip>, z.ZodObject<{
+        artifact: z.ZodObject<{
+            artifactId: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            parts: z.ZodArray<z.ZodObject<{
+                text: z.ZodOptional<z.ZodString>;
+                raw: z.ZodOptional<z.ZodString>;
+                url: z.ZodOptional<z.ZodString>;
+                data: z.ZodOptional<z.ZodUnknown>;
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                filename: z.ZodOptional<z.ZodString>;
+                mediaType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>;
+        append: z.ZodOptional<z.ZodBoolean>;
+        lastChunk: z.ZodOptional<z.ZodBoolean>;
+    }, z.core.$strip>]>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"contacts">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"relay">;
+    connected: z.ZodBoolean;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"conv">;
+    conversation: z.ZodString;
+    id: z.ZodString;
+    person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+    seq: z.ZodNumber;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"login">;
+    state: z.ZodEnum<{
+        pending: "pending";
+        done: "done";
+        failed: "failed";
+        cancelled: "cancelled";
+    }>;
+    purpose: z.ZodEnum<{
+        bind: "bind";
+        replace: "replace";
+        remove: "remove";
+        erase: "erase";
+    }>;
+    code: z.ZodOptional<z.ZodEnum<{
+        expired: "expired";
+        invalid_request: "invalid_request";
+        not_member: "not_member";
+        bad_signature: "bad_signature";
+        unknown_session: "unknown_session";
+        ambiguous_address: "ambiguous_address";
+        no_recipients: "no_recipients";
+        unknown_address: "unknown_address";
+        refused: "refused";
+        declined: "declined";
+        request_required: "request_required";
+        rate_limited: "rate_limited";
+        loop_guard: "loop_guard";
+        too_large: "too_large";
+        secret_refused: "secret_refused";
+        duplicate: "duplicate";
+        relay_unavailable: "relay_unavailable";
+        not_found: "not_found";
+        invalid_state: "invalid_state";
+        forbidden: "forbidden";
+        guarded_turn: "guarded_turn";
+        roster_conflict: "roster_conflict";
+        invite_invalid: "invite_invalid";
+        no_identity: "no_identity";
+        binding_invalid: "binding_invalid";
+        jelly_unavailable: "jelly_unavailable";
+        log_conflict: "log_conflict";
+        conv_conflict: "conv_conflict";
+        stale_epoch: "stale_epoch";
+        device_limit: "device_limit";
+        admission_required: "admission_required";
+        admission_invalid: "admission_invalid";
+        directory_inconsistent: "directory_inconsistent";
+        unknown_device: "unknown_device";
+        directory_unavailable: "directory_unavailable";
+        login_unsupported: "login_unsupported";
+        login_denied: "login_denied";
+        grant_required: "grant_required";
+        grant_invalid: "grant_invalid";
+        ticket_required: "ticket_required";
+        ticket_invalid: "ticket_invalid";
+        daemon_unavailable: "daemon_unavailable";
+        daemon_mismatch: "daemon_mismatch";
+        store_refused: "store_refused";
+        internal: "internal";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"notice">;
+    notice: z.ZodObject<{
+        id: z.ZodString;
+        category: z.ZodEnum<{
+            message: "message";
+            request: "request";
+            alert: "alert";
+        }>;
+        conversation: z.ZodOptional<z.ZodString>;
+        from: z.ZodOptional<z.ZodObject<{
+            name: z.ZodString;
+            email: z.ZodOptional<z.ZodString>;
+            org: z.ZodEnum<{
+                other: "other";
+                none: "none";
+                same: "same";
+            }>;
+        }, z.core.$strip>>;
+        line: z.ZodOptional<z.ZodString>;
+        device: z.ZodOptional<z.ZodObject<{
+            change: z.ZodEnum<{
+                removed: "removed";
+                replaced: "replaced";
+                added: "added";
+                vouched: "vouched";
+            }>;
+            device: z.ZodString;
+            label: z.ZodString;
+            kind: z.ZodOptional<z.ZodEnum<{
+                "jelly-host": "jelly-host";
+                laptop: "laptop";
+                server: "server";
+                other: "other";
+            }>>;
+            vouch: z.ZodEnum<{
+                admin: "admin";
+                device: "device";
+                jelly: "jelly";
+            }>;
+            via: z.ZodOptional<z.ZodEnum<{
+                host: "host";
+                browser: "browser";
+            }>>;
+            approver: z.ZodOptional<z.ZodString>;
+            at: z.ZodNumber;
+            replaces: z.ZodOptional<z.ZodObject<{
+                device: z.ZodString;
+                label: z.ZodString;
+            }, z.core.$strip>>;
+            current: z.ZodBoolean;
+            remove: z.ZodOptional<z.ZodEnum<{
+                token: "token";
+                "sign-in": "sign-in";
+                team: "team";
+            }>>;
+        }, z.core.$strip>>;
+        at: z.ZodNumber;
+    }, z.core.$strip>;
+}, z.core.$strip>], "type">;
+export type IpcEvent = z.infer<typeof IpcEvent>;