@joe-broadhead/messaging 0.7.0 → 0.8.0

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

@@ -15,11 +15,14 @@
  *
  * 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).
+ * The daemon pushes notifications `{"jsonrpc":"2.0","method":"event","params":Event}` to connections
+ * subscribed to the event's key. Notice subscriptions are human-only. Conversations use `conv.sync`.
  */
 import { z } from "zod";
+import { CONVERSATION_TIERS, type LiveConversationMethod } from "./ipc/conversations.js";
+type ConversationTier<T extends "agent" | "human"> = {
+    [M in LiveConversationMethod]: typeof CONVERSATION_TIERS[M] extends T ? M : never;
+}[LiveConversationMethod];
 export * from "./ipc/shapes.js";
 export * from "./ipc/surfaces.js";
 export * from "./ipc/jelly.js";
@@ -144,6 +147,2374 @@ export declare const InviteSummary: z.ZodObject<{
 }, z.core.$strip>;
 /** Method table: name → params/result schemas. The daemon validates params; clients validate results. */
 export declare const IPC_METHODS: {
+    readonly "conv.list": {
+        params: z.ZodObject<{
+            limit: z.ZodOptional<z.ZodNumber>;
+            cursor: z.ZodOptional<z.ZodString>;
+            key: z.ZodOptional<z.ZodString>;
+            filter: z.ZodOptional<z.ZodObject<{
+                unread: z.ZodOptional<z.ZodBoolean>;
+                mentions: z.ZodOptional<z.ZodBoolean>;
+                kind: z.ZodOptional<z.ZodEnum<{
+                    self: "self";
+                    channel: "channel";
+                    group: "group";
+                    dm: "dm";
+                }>>;
+                archived: z.ZodOptional<z.ZodBoolean>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        result: z.ZodObject<{
+            conversations: z.ZodArray<z.ZodObject<{
+                cid: z.ZodString;
+                kind: z.ZodEnum<{
+                    self: "self";
+                    channel: "channel";
+                    group: "group";
+                    dm: "dm";
+                }>;
+                visibility: z.ZodOptional<z.ZodEnum<{
+                    public: "public";
+                    private: "private";
+                }>>;
+                history: z.ZodEnum<{
+                    none: "none";
+                    shared: "shared";
+                }>;
+                retainDays: z.ZodNumber;
+                agentContext: z.ZodEnum<{
+                    none: "none";
+                    members: "members";
+                    seats: "seats";
+                }>;
+                name: z.ZodOptional<z.ZodString>;
+                topic: z.ZodOptional<z.ZodString>;
+                purpose: z.ZodOptional<z.ZodString>;
+                archived: z.ZodBoolean;
+                role: z.ZodEnum<{
+                    admin: "admin";
+                    member: "member";
+                    owner: "owner";
+                    guest: "guest";
+                }>;
+                participants: z.ZodNumber;
+                dmWith: z.ZodOptional<z.ZodObject<{
+                    p: z.ZodString;
+                    kind: z.ZodEnum<{
+                        person: "person";
+                        agent: "agent";
+                    }>;
+                    role: z.ZodEnum<{
+                        admin: "admin";
+                        member: "member";
+                        owner: "owner";
+                        guest: "guest";
+                    }>;
+                    state: z.ZodEnum<{
+                        member: "member";
+                        invited: "invited";
+                    }>;
+                    name: z.ZodString;
+                    handle: z.ZodOptional<z.ZodString>;
+                    org: z.ZodEnum<{
+                        other: "other";
+                        none: "none";
+                        same: "same";
+                    }>;
+                    presence: z.ZodEnum<{
+                        unknown: "unknown";
+                        away: "away";
+                        offline: "offline";
+                        online: "online";
+                    }>;
+                    agentState: z.ZodOptional<z.ZodEnum<{
+                        idle: "idle";
+                        busy: "busy";
+                        kept: "kept";
+                    }>>;
+                    respondTo: z.ZodOptional<z.ZodEnum<{
+                        self: "self";
+                        none: "none";
+                        members: "members";
+                    }>>;
+                }, z.core.$strip>>;
+                last: z.ZodOptional<z.ZodObject<{
+                    cid: z.ZodString;
+                    id: z.ZodString;
+                    seq: z.ZodNumber;
+                    at: z.ZodNumber;
+                    author: z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodEnum<{
+                            person: "person";
+                            agent: "agent";
+                        }>;
+                        p: z.ZodString;
+                    }, z.core.$strip>;
+                    kind: z.ZodEnum<{
+                        task: "task";
+                        line: "line";
+                        notice: "notice";
+                    }>;
+                    text: z.ZodOptional<z.ZodString>;
+                    format: z.ZodOptional<z.ZodEnum<{
+                        plain: "plain";
+                        md: "md";
+                    }>>;
+                    thread: z.ZodOptional<z.ZodString>;
+                    broadcast: z.ZodOptional<z.ZodBoolean>;
+                    mentions: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                        p: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        all: z.ZodLiteral<"channel">;
+                    }, z.core.$strict>, z.ZodObject<{
+                        all: z.ZodLiteral<"here">;
+                    }, z.core.$strict>]>>>;
+                    mentionsMe: z.ZodBoolean;
+                    files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        blob: z.ZodString;
+                        name: z.ZodString;
+                        mime: z.ZodString;
+                        bytes: z.ZodNumber;
+                    }, z.core.$strip>>>;
+                    edited: z.ZodOptional<z.ZodNumber>;
+                    deleted: z.ZodOptional<z.ZodBoolean>;
+                    reactions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        key: z.ZodString;
+                        count: z.ZodNumber;
+                        mine: z.ZodBoolean;
+                    }, z.core.$strip>>>;
+                    pinned: z.ZodOptional<z.ZodBoolean>;
+                    replies: z.ZodOptional<z.ZodObject<{
+                        count: z.ZodNumber;
+                        lastAt: z.ZodNumber;
+                        participants: z.ZodArray<z.ZodString>;
+                        unread: z.ZodOptional<z.ZodNumber>;
+                        following: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>>;
+                    task: z.ZodOptional<z.ZodObject<{
+                        id: 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";
+                        }>;
+                    }, z.core.$strip>>;
+                    notice: z.ZodOptional<z.ZodObject<{
+                        op: z.ZodEnum<{
+                            role: "role";
+                            remove: "remove";
+                            accept: "accept";
+                            settings: "settings";
+                            create: "create";
+                            add: "add";
+                            join: "join";
+                            leave: "leave";
+                            seat: "seat";
+                            archive: "archive";
+                            policy: "policy";
+                            meta: "meta";
+                        }>;
+                        by: z.ZodObject<{
+                            name: z.ZodString;
+                            kind: z.ZodEnum<{
+                                person: "person";
+                                agent: "agent";
+                            }>;
+                            p: z.ZodString;
+                        }, z.core.$strip>;
+                        participants: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            kind: z.ZodEnum<{
+                                person: "person";
+                                agent: "agent";
+                            }>;
+                            p: z.ZodString;
+                        }, z.core.$strip>>>;
+                        fields: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                            name: "name";
+                            history: "history";
+                            purpose: "purpose";
+                            agentContext: "agentContext";
+                            bridges: "bridges";
+                            visibility: "visibility";
+                            retainDays: "retainDays";
+                            post: "post";
+                            invite: "invite";
+                            pins: "pins";
+                            topic: "topic";
+                        }>>>;
+                    }, z.core.$strip>>;
+                    delivery: z.ZodOptional<z.ZodEnum<{
+                        delivered: "delivered";
+                        read: "read";
+                        pending: "pending";
+                        failed: "failed";
+                        sent: "sent";
+                    }>>;
+                    clientId: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                headSeq: z.ZodNumber;
+                readUpTo: z.ZodOptional<z.ZodNumber>;
+                unread: z.ZodOptional<z.ZodNumber>;
+                mentions: z.ZodOptional<z.ZodNumber>;
+                threadsUnread: z.ZodOptional<z.ZodNumber>;
+                notify: z.ZodOptional<z.ZodEnum<{
+                    none: "none";
+                    all: "all";
+                    mentions: "mentions";
+                }>>;
+                mutedUntil: z.ZodOptional<z.ZodNumber>;
+                draft: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            cursor: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        errors: readonly ["invalid_request", "forbidden", "not_found", "too_large", "internal", "no_identity", "unknown_session", "grant_required", "grant_invalid", "directory_unavailable", "directory_inconsistent", "relay_unavailable"];
+    };
+    readonly "conv.get": {
+        params: z.ZodObject<{
+            cid: z.ZodString;
+            key: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        result: z.ZodObject<{
+            cid: z.ZodString;
+            kind: z.ZodEnum<{
+                self: "self";
+                channel: "channel";
+                group: "group";
+                dm: "dm";
+            }>;
+            visibility: z.ZodOptional<z.ZodEnum<{
+                public: "public";
+                private: "private";
+            }>>;
+            history: z.ZodEnum<{
+                none: "none";
+                shared: "shared";
+            }>;
+            retainDays: z.ZodNumber;
+            agentContext: z.ZodEnum<{
+                none: "none";
+                members: "members";
+                seats: "seats";
+            }>;
+            name: z.ZodOptional<z.ZodString>;
+            topic: z.ZodOptional<z.ZodString>;
+            purpose: z.ZodOptional<z.ZodString>;
+            archived: z.ZodBoolean;
+            role: z.ZodEnum<{
+                admin: "admin";
+                member: "member";
+                owner: "owner";
+                guest: "guest";
+            }>;
+            participants: z.ZodNumber;
+            dmWith: z.ZodOptional<z.ZodObject<{
+                p: z.ZodString;
+                kind: z.ZodEnum<{
+                    person: "person";
+                    agent: "agent";
+                }>;
+                role: z.ZodEnum<{
+                    admin: "admin";
+                    member: "member";
+                    owner: "owner";
+                    guest: "guest";
+                }>;
+                state: z.ZodEnum<{
+                    member: "member";
+                    invited: "invited";
+                }>;
+                name: z.ZodString;
+                handle: z.ZodOptional<z.ZodString>;
+                org: z.ZodEnum<{
+                    other: "other";
+                    none: "none";
+                    same: "same";
+                }>;
+                presence: z.ZodEnum<{
+                    unknown: "unknown";
+                    away: "away";
+                    offline: "offline";
+                    online: "online";
+                }>;
+                agentState: z.ZodOptional<z.ZodEnum<{
+                    idle: "idle";
+                    busy: "busy";
+                    kept: "kept";
+                }>>;
+                respondTo: z.ZodOptional<z.ZodEnum<{
+                    self: "self";
+                    none: "none";
+                    members: "members";
+                }>>;
+            }, z.core.$strip>>;
+            last: z.ZodOptional<z.ZodObject<{
+                cid: z.ZodString;
+                id: z.ZodString;
+                seq: z.ZodNumber;
+                at: z.ZodNumber;
+                author: z.ZodObject<{
+                    name: z.ZodString;
+                    kind: z.ZodEnum<{
+                        person: "person";
+                        agent: "agent";
+                    }>;
+                    p: z.ZodString;
+                }, z.core.$strip>;
+                kind: z.ZodEnum<{
+                    task: "task";
+                    line: "line";
+                    notice: "notice";
+                }>;
+                text: z.ZodOptional<z.ZodString>;
+                format: z.ZodOptional<z.ZodEnum<{
+                    plain: "plain";
+                    md: "md";
+                }>>;
+                thread: z.ZodOptional<z.ZodString>;
+                broadcast: z.ZodOptional<z.ZodBoolean>;
+                mentions: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    p: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    all: z.ZodLiteral<"channel">;
+                }, z.core.$strict>, z.ZodObject<{
+                    all: z.ZodLiteral<"here">;
+                }, z.core.$strict>]>>>;
+                mentionsMe: z.ZodBoolean;
+                files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    blob: z.ZodString;
+                    name: z.ZodString;
+                    mime: z.ZodString;
+                    bytes: z.ZodNumber;
+                }, z.core.$strip>>>;
+                edited: z.ZodOptional<z.ZodNumber>;
+                deleted: z.ZodOptional<z.ZodBoolean>;
+                reactions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    key: z.ZodString;
+                    count: z.ZodNumber;
+                    mine: z.ZodBoolean;
+                }, z.core.$strip>>>;
+                pinned: z.ZodOptional<z.ZodBoolean>;
+                replies: z.ZodOptional<z.ZodObject<{
+                    count: z.ZodNumber;
+                    lastAt: z.ZodNumber;
+                    participants: z.ZodArray<z.ZodString>;
+                    unread: z.ZodOptional<z.ZodNumber>;
+                    following: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                task: z.ZodOptional<z.ZodObject<{
+                    id: 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";
+                    }>;
+                }, z.core.$strip>>;
+                notice: z.ZodOptional<z.ZodObject<{
+                    op: z.ZodEnum<{
+                        role: "role";
+                        remove: "remove";
+                        accept: "accept";
+                        settings: "settings";
+                        create: "create";
+                        add: "add";
+                        join: "join";
+                        leave: "leave";
+                        seat: "seat";
+                        archive: "archive";
+                        policy: "policy";
+                        meta: "meta";
+                    }>;
+                    by: z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodEnum<{
+                            person: "person";
+                            agent: "agent";
+                        }>;
+                        p: z.ZodString;
+                    }, z.core.$strip>;
+                    participants: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodEnum<{
+                            person: "person";
+                            agent: "agent";
+                        }>;
+                        p: z.ZodString;
+                    }, z.core.$strip>>>;
+                    fields: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                        name: "name";
+                        history: "history";
+                        purpose: "purpose";
+                        agentContext: "agentContext";
+                        bridges: "bridges";
+                        visibility: "visibility";
+                        retainDays: "retainDays";
+                        post: "post";
+                        invite: "invite";
+                        pins: "pins";
+                        topic: "topic";
+                    }>>>;
+                }, z.core.$strip>>;
+                delivery: z.ZodOptional<z.ZodEnum<{
+                    delivered: "delivered";
+                    read: "read";
+                    pending: "pending";
+                    failed: "failed";
+                    sent: "sent";
+                }>>;
+                clientId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            headSeq: z.ZodNumber;
+            readUpTo: z.ZodOptional<z.ZodNumber>;
+            unread: z.ZodOptional<z.ZodNumber>;
+            mentions: z.ZodOptional<z.ZodNumber>;
+            threadsUnread: z.ZodOptional<z.ZodNumber>;
+            notify: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                all: "all";
+                mentions: "mentions";
+            }>>;
+            mutedUntil: z.ZodOptional<z.ZodNumber>;
+            draft: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        errors: readonly ["invalid_request", "forbidden", "not_found", "too_large", "internal", "no_identity", "unknown_session", "grant_required", "grant_invalid", "directory_unavailable", "directory_inconsistent", "relay_unavailable"];
+    };
+    readonly "conv.members": {
+        params: z.ZodObject<{
+            limit: z.ZodOptional<z.ZodNumber>;
+            cursor: z.ZodOptional<z.ZodString>;
+            cid: z.ZodString;
+        }, z.core.$strict>;
+        result: z.ZodObject<{
+            participants: z.ZodArray<z.ZodObject<{
+                p: z.ZodString;
+                kind: z.ZodEnum<{
+                    person: "person";
+                    agent: "agent";
+                }>;
+                role: z.ZodEnum<{
+                    admin: "admin";
+                    member: "member";
+                    owner: "owner";
+                    guest: "guest";
+                }>;
+                state: z.ZodEnum<{
+                    member: "member";
+                    invited: "invited";
+                }>;
+                name: z.ZodString;
+                handle: z.ZodOptional<z.ZodString>;
+                org: z.ZodEnum<{
+                    other: "other";
+                    none: "none";
+                    same: "same";
+                }>;
+                presence: z.ZodEnum<{
+                    unknown: "unknown";
+                    away: "away";
+                    offline: "offline";
+                    online: "online";
+                }>;
+                agentState: z.ZodOptional<z.ZodEnum<{
+                    idle: "idle";
+                    busy: "busy";
+                    kept: "kept";
+                }>>;
+                respondTo: z.ZodOptional<z.ZodEnum<{
+                    self: "self";
+                    none: "none";
+                    members: "members";
+                }>>;
+            }, z.core.$strip>>;
+            cursor: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        errors: readonly ["invalid_request", "forbidden", "not_found", "too_large", "internal", "no_identity", "unknown_session", "grant_required", "grant_invalid", "directory_unavailable", "directory_inconsistent", "relay_unavailable"];
+    };
+    readonly "conv.read": {
+        params: z.ZodObject<{
+            thread: z.ZodOptional<z.ZodString>;
+            before: z.ZodOptional<z.ZodNumber>;
+            after: z.ZodOptional<z.ZodNumber>;
+            around: z.ZodOptional<z.ZodString>;
+            limit: z.ZodOptional<z.ZodNumber>;
+            cursor: z.ZodOptional<z.ZodString>;
+            cid: z.ZodString;
+            key: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        result: z.ZodUnion<readonly [z.ZodObject<{
+            events: z.ZodArray<z.ZodObject<{
+                cid: z.ZodString;
+                id: z.ZodString;
+                seq: z.ZodNumber;
+                at: z.ZodNumber;
+                author: z.ZodObject<{
+                    name: z.ZodString;
+                    kind: z.ZodEnum<{
+                        person: "person";
+                        agent: "agent";
+                    }>;
+                    p: z.ZodString;
+                }, z.core.$strip>;
+                kind: z.ZodEnum<{
+                    task: "task";
+                    line: "line";
+                    notice: "notice";
+                }>;
+                text: z.ZodOptional<z.ZodString>;
+                format: z.ZodOptional<z.ZodEnum<{
+                    plain: "plain";
+                    md: "md";
+                }>>;
+                thread: z.ZodOptional<z.ZodString>;
+                broadcast: z.ZodOptional<z.ZodBoolean>;
+                mentions: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    p: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    all: z.ZodLiteral<"channel">;
+                }, z.core.$strict>, z.ZodObject<{
+                    all: z.ZodLiteral<"here">;
+                }, z.core.$strict>]>>>;
+                mentionsMe: z.ZodBoolean;
+                files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    blob: z.ZodString;
+                    name: z.ZodString;
+                    mime: z.ZodString;
+                    bytes: z.ZodNumber;
+                }, z.core.$strip>>>;
+                edited: z.ZodOptional<z.ZodNumber>;
+                deleted: z.ZodOptional<z.ZodBoolean>;
+                reactions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    key: z.ZodString;
+                    count: z.ZodNumber;
+                    mine: z.ZodBoolean;
+                }, z.core.$strip>>>;
+                pinned: z.ZodOptional<z.ZodBoolean>;
+                replies: z.ZodOptional<z.ZodObject<{
+                    count: z.ZodNumber;
+                    lastAt: z.ZodNumber;
+                    participants: z.ZodArray<z.ZodString>;
+                    unread: z.ZodOptional<z.ZodNumber>;
+                    following: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                task: z.ZodOptional<z.ZodObject<{
+                    id: 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";
+                    }>;
+                }, z.core.$strip>>;
+                notice: z.ZodOptional<z.ZodObject<{
+                    op: z.ZodEnum<{
+                        role: "role";
+                        remove: "remove";
+                        accept: "accept";
+                        settings: "settings";
+                        create: "create";
+                        add: "add";
+                        join: "join";
+                        leave: "leave";
+                        seat: "seat";
+                        archive: "archive";
+                        policy: "policy";
+                        meta: "meta";
+                    }>;
+                    by: z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodEnum<{
+                            person: "person";
+                            agent: "agent";
+                        }>;
+                        p: z.ZodString;
+                    }, z.core.$strip>;
+                    participants: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodEnum<{
+                            person: "person";
+                            agent: "agent";
+                        }>;
+                        p: z.ZodString;
+                    }, z.core.$strip>>>;
+                    fields: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                        name: "name";
+                        history: "history";
+                        purpose: "purpose";
+                        agentContext: "agentContext";
+                        bridges: "bridges";
+                        visibility: "visibility";
+                        retainDays: "retainDays";
+                        post: "post";
+                        invite: "invite";
+                        pins: "pins";
+                        topic: "topic";
+                    }>>>;
+                }, z.core.$strip>>;
+                delivery: z.ZodOptional<z.ZodEnum<{
+                    delivered: "delivered";
+                    read: "read";
+                    pending: "pending";
+                    failed: "failed";
+                    sent: "sent";
+                }>>;
+                clientId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            more: z.ZodBoolean;
+            cursor: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            stage: z.ZodLiteral<"held">;
+            code: z.ZodEnum<{
+                audience: "audience";
+                context: "context";
+            }>;
+            expect: z.ZodLiteral<"on_consent">;
+        }, z.core.$strip>]>;
+        errors: readonly ["invalid_request", "forbidden", "not_found", "too_large", "internal", "no_identity", "unknown_session", "grant_required", "grant_invalid", "directory_unavailable", "directory_inconsistent", "relay_unavailable"];
+    };
+    readonly "conv.threads": {
+        params: z.ZodObject<{
+            limit: z.ZodOptional<z.ZodNumber>;
+            cursor: z.ZodOptional<z.ZodString>;
+            filter: z.ZodOptional<z.ZodEnum<{
+                all: "all";
+                unread: "unread";
+                following: "following";
+            }>>;
+            cid: z.ZodString;
+        }, z.core.$strict>;
+        result: z.ZodObject<{
+            events: z.ZodArray<z.ZodObject<{
+                cid: z.ZodString;
+                id: z.ZodString;
+                seq: z.ZodNumber;
+                at: z.ZodNumber;
+                author: z.ZodObject<{
+                    name: z.ZodString;
+                    kind: z.ZodEnum<{
+                        person: "person";
+                        agent: "agent";
+                    }>;
+                    p: z.ZodString;
+                }, z.core.$strip>;
+                kind: z.ZodEnum<{
+                    task: "task";
+                    line: "line";
+                    notice: "notice";
+                }>;
+                text: z.ZodOptional<z.ZodString>;
+                format: z.ZodOptional<z.ZodEnum<{
+                    plain: "plain";
+                    md: "md";
+                }>>;
+                thread: z.ZodOptional<z.ZodString>;
+                broadcast: z.ZodOptional<z.ZodBoolean>;
+                mentions: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    p: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    all: z.ZodLiteral<"channel">;
+                }, z.core.$strict>, z.ZodObject<{
+                    all: z.ZodLiteral<"here">;
+                }, z.core.$strict>]>>>;
+                mentionsMe: z.ZodBoolean;
+                files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    blob: z.ZodString;
+                    name: z.ZodString;
+                    mime: z.ZodString;
+                    bytes: z.ZodNumber;
+                }, z.core.$strip>>>;
+                edited: z.ZodOptional<z.ZodNumber>;
+                deleted: z.ZodOptional<z.ZodBoolean>;
+                reactions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    key: z.ZodString;
+                    count: z.ZodNumber;
+                    mine: z.ZodBoolean;
+                }, z.core.$strip>>>;
+                pinned: z.ZodOptional<z.ZodBoolean>;
+                replies: z.ZodOptional<z.ZodObject<{
+                    count: z.ZodNumber;
+                    lastAt: z.ZodNumber;
+                    participants: z.ZodArray<z.ZodString>;
+                    unread: z.ZodOptional<z.ZodNumber>;
+                    following: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                task: z.ZodOptional<z.ZodObject<{
+                    id: 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";
+                    }>;
+                }, z.core.$strip>>;
+                notice: z.ZodOptional<z.ZodObject<{
+                    op: z.ZodEnum<{
+                        role: "role";
+                        remove: "remove";
+                        accept: "accept";
+                        settings: "settings";
+                        create: "create";
+                        add: "add";
+                        join: "join";
+                        leave: "leave";
+                        seat: "seat";
+                        archive: "archive";
+                        policy: "policy";
+                        meta: "meta";
+                    }>;
+                    by: z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodEnum<{
+                            person: "person";
+                            agent: "agent";
+                        }>;
+                        p: z.ZodString;
+                    }, z.core.$strip>;
+                    participants: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodEnum<{
+                            person: "person";
+                            agent: "agent";
+                        }>;
+                        p: z.ZodString;
+                    }, z.core.$strip>>>;
+                    fields: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                        name: "name";
+                        history: "history";
+                        purpose: "purpose";
+                        agentContext: "agentContext";
+                        bridges: "bridges";
+                        visibility: "visibility";
+                        retainDays: "retainDays";
+                        post: "post";
+                        invite: "invite";
+                        pins: "pins";
+                        topic: "topic";
+                    }>>>;
+                }, z.core.$strip>>;
+                delivery: z.ZodOptional<z.ZodEnum<{
+                    delivered: "delivered";
+                    read: "read";
+                    pending: "pending";
+                    failed: "failed";
+                    sent: "sent";
+                }>>;
+                clientId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            more: z.ZodBoolean;
+            cursor: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        errors: readonly ["invalid_request", "forbidden", "not_found", "too_large", "internal", "no_identity", "unknown_session", "grant_required", "grant_invalid", "directory_unavailable", "directory_inconsistent", "relay_unavailable"];
+    };
+    readonly "conv.send": {
+        readonly params: z.ZodObject<{
+            answer: z.ZodOptional<z.ZodString>;
+            clientId: z.ZodString;
+            text: z.ZodString;
+            format: z.ZodOptional<z.ZodEnum<{
+                plain: "plain";
+                md: "md";
+            }>>;
+            thread: z.ZodOptional<z.ZodString>;
+            broadcast: z.ZodOptional<z.ZodBoolean>;
+            mentions: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                p: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                all: z.ZodLiteral<"channel">;
+            }, z.core.$strict>, z.ZodObject<{
+                all: z.ZodLiteral<"here">;
+            }, z.core.$strict>]>>>;
+            files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                blob: z.ZodString;
+                key: z.ZodString;
+                nonce: z.ZodString;
+                sha256: z.ZodString;
+                bytes: z.ZodNumber;
+                mime: z.ZodString;
+                name: z.ZodString;
+                thumb: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>>;
+            key: z.ZodOptional<z.ZodString>;
+            cid: z.ZodOptional<z.ZodString>;
+            to: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        readonly result: z.ZodUnion<readonly [z.ZodObject<{
+            cid: z.ZodString;
+            id: z.ZodString;
+            clientId: z.ZodString;
+            stage: z.ZodLiteral<"pending">;
+        }, z.core.$strip>, z.ZodObject<{
+            stage: z.ZodLiteral<"held">;
+            code: z.ZodEnum<{
+                audience: "audience";
+                context: "context";
+            }>;
+            expect: z.ZodLiteral<"on_consent">;
+        }, z.core.$strip>]>;
+        readonly errors: readonly ["invalid_request", "forbidden", "not_found", "too_large", "internal", "no_identity", "unknown_session", "grant_required", "grant_invalid", "directory_unavailable", "directory_inconsistent", "invalid_state", "conv_conflict", "stale_epoch", "relay_unavailable", "rate_limited", "duplicate", "secret_refused", "refused", "declined", "request_required", "loop_guard", "unknown_device", "binding_invalid"];
+    };
+    readonly "conv.react": {
+        params: z.ZodObject<{
+            reaction: z.ZodString;
+            on: z.ZodBoolean;
+            cid: z.ZodString;
+            id: z.ZodString;
+            key: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        result: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+        errors: readonly ["invalid_request", "forbidden", "not_found", "too_large", "internal", "no_identity", "unknown_session", "grant_required", "grant_invalid", "directory_unavailable", "directory_inconsistent", "invalid_state", "conv_conflict", "stale_epoch", "relay_unavailable", "rate_limited", "duplicate", "secret_refused", "refused", "declined", "request_required", "loop_guard", "unknown_device", "binding_invalid"];
+    };
+    readonly "conv.edit": {
+        params: z.ZodObject<{
+            text: z.ZodString;
+            mentions: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                p: z.ZodString;
+            }, z.core.$strict>, z.ZodObject<{
+                all: z.ZodLiteral<"channel">;
+            }, z.core.$strict>, z.ZodObject<{
+                all: z.ZodLiteral<"here">;
+            }, z.core.$strict>]>>>;
+            cid: z.ZodString;
+            id: z.ZodString;
+            key: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        result: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+        errors: readonly ["invalid_request", "forbidden", "not_found", "too_large", "internal", "no_identity", "unknown_session", "grant_required", "grant_invalid", "directory_unavailable", "directory_inconsistent", "invalid_state", "conv_conflict", "stale_epoch", "relay_unavailable", "rate_limited", "duplicate", "secret_refused", "refused", "declined", "request_required", "loop_guard", "unknown_device", "binding_invalid"];
+    };
+    readonly "conv.delete": {
+        params: z.ZodObject<{
+            cid: z.ZodString;
+            id: z.ZodString;
+            key: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        result: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+        errors: readonly ["invalid_request", "forbidden", "not_found", "too_large", "internal", "no_identity", "unknown_session", "grant_required", "grant_invalid", "directory_unavailable", "directory_inconsistent", "invalid_state", "conv_conflict", "stale_epoch", "relay_unavailable", "rate_limited", "duplicate", "secret_refused", "refused", "declined", "request_required", "loop_guard", "unknown_device", "binding_invalid"];
+    };
+    readonly "conv.pin": {
+        params: z.ZodObject<{
+            on: z.ZodBoolean;
+            cid: z.ZodString;
+            id: z.ZodString;
+        }, z.core.$strict>;
+        result: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+        errors: readonly ["invalid_request", "forbidden", "not_found", "too_large", "internal", "no_identity", "unknown_session", "grant_required", "grant_invalid", "directory_unavailable", "directory_inconsistent", "invalid_state", "conv_conflict", "stale_epoch", "relay_unavailable", "rate_limited", "duplicate", "secret_refused", "refused", "declined", "request_required", "loop_guard", "unknown_device", "binding_invalid"];
+    };
+    readonly "conv.create": {
+        readonly params: z.ZodObject<{
+            kind: z.ZodEnum<{
+                channel: "channel";
+                group: "group";
+                dm: "dm";
+            }>;
+            participants: z.ZodArray<z.ZodObject<{
+                p: z.ZodString;
+                role: z.ZodEnum<{
+                    admin: "admin";
+                    member: "member";
+                    owner: "owner";
+                    guest: "guest";
+                }>;
+                device: z.ZodOptional<z.ZodString>;
+                respondTo: z.ZodOptional<z.ZodEnum<{
+                    self: "self";
+                    none: "none";
+                    members: "members";
+                }>>;
+            }, z.core.$strict>>;
+            visibility: z.ZodOptional<z.ZodEnum<{
+                public: "public";
+                private: "private";
+            }>>;
+            history: z.ZodEnum<{
+                none: "none";
+                shared: "shared";
+            }>;
+            retainDays: z.ZodNumber;
+            meta: z.ZodOptional<z.ZodObject<{
+                name: z.ZodOptional<z.ZodString>;
+                topic: z.ZodOptional<z.ZodString>;
+                purpose: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>>;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            cid: z.ZodString;
+        }, z.core.$strip>;
+        readonly errors: readonly ["invalid_request", "forbidden", "not_found", "too_large", "internal", "no_identity", "unknown_session", "grant_required", "grant_invalid", "directory_unavailable", "directory_inconsistent", "invalid_state", "conv_conflict", "stale_epoch", "relay_unavailable", "rate_limited", "duplicate", "secret_refused", "refused", "declined", "request_required", "loop_guard", "unknown_device", "binding_invalid"];
+    };
+    readonly "conv.add": {
+        params: z.ZodObject<{
+            participants: z.ZodArray<z.ZodObject<{
+                p: z.ZodString;
+                role: z.ZodEnum<{
+                    admin: "admin";
+                    member: "member";
+                    owner: "owner";
+                    guest: "guest";
+                }>;
+                device: z.ZodOptional<z.ZodString>;
+                respondTo: z.ZodOptional<z.ZodEnum<{
+                    self: "self";
+                    none: "none";
+                    members: "members";
+                }>>;
+            }, z.core.$strict>>;
+            cid: z.ZodString;
+        }, z.core.$strict>;
+        result: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+        errors: readonly ["invalid_request", "forbidden", "not_found", "too_large", "internal", "no_identity", "unknown_session", "grant_required", "grant_invalid", "directory_unavailable", "directory_inconsistent", "invalid_state", "conv_conflict", "stale_epoch", "relay_unavailable", "rate_limited", "duplicate", "secret_refused", "refused", "declined", "request_required", "loop_guard", "unknown_device", "binding_invalid"];
+    };
+    readonly "conv.remove": {
+        params: z.ZodObject<{
+            participants: z.ZodArray<z.ZodString>;
+            cid: z.ZodString;
+        }, z.core.$strict>;
+        result: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+        errors: readonly ["invalid_request", "forbidden", "not_found", "too_large", "internal", "no_identity", "unknown_session", "grant_required", "grant_invalid", "directory_unavailable", "directory_inconsistent", "invalid_state", "conv_conflict", "stale_epoch", "relay_unavailable", "rate_limited", "duplicate", "secret_refused", "refused", "declined", "request_required", "loop_guard", "unknown_device", "binding_invalid"];
+    };
+    readonly "conv.role": {
+        params: z.ZodObject<{
+            p: z.ZodString;
+            role: z.ZodEnum<{
+                admin: "admin";
+                member: "member";
+                owner: "owner";
+                guest: "guest";
+            }>;
+            cid: z.ZodString;
+        }, z.core.$strict>;
+        result: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+        errors: readonly ["invalid_request", "forbidden", "not_found", "too_large", "internal", "no_identity", "unknown_session", "grant_required", "grant_invalid", "directory_unavailable", "directory_inconsistent", "invalid_state", "conv_conflict", "stale_epoch", "relay_unavailable", "rate_limited", "duplicate", "secret_refused", "refused", "declined", "request_required", "loop_guard", "unknown_device", "binding_invalid"];
+    };
+    readonly "conv.seat": {
+        params: z.ZodObject<{
+            p: z.ZodString;
+            device: z.ZodOptional<z.ZodString>;
+            respondTo: z.ZodOptional<z.ZodEnum<{
+                self: "self";
+                none: "none";
+                members: "members";
+            }>>;
+            cid: z.ZodString;
+        }, z.core.$strict>;
+        result: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+        errors: readonly ["invalid_request", "forbidden", "not_found", "too_large", "internal", "no_identity", "unknown_session", "grant_required", "grant_invalid", "directory_unavailable", "directory_inconsistent", "invalid_state", "conv_conflict", "stale_epoch", "relay_unavailable", "rate_limited", "duplicate", "secret_refused", "refused", "declined", "request_required", "loop_guard", "unknown_device", "binding_invalid"];
+    };
+    readonly "conv.settings": {
+        params: z.ZodObject<{
+            visibility: z.ZodOptional<z.ZodEnum<{
+                public: "public";
+                private: "private";
+            }>>;
+            history: z.ZodOptional<z.ZodEnum<{
+                none: "none";
+                shared: "shared";
+            }>>;
+            retainDays: z.ZodOptional<z.ZodNumber>;
+            post: z.ZodOptional<z.ZodEnum<{
+                admins: "admins";
+                all: "all";
+            }>>;
+            invite: z.ZodOptional<z.ZodEnum<{
+                admins: "admins";
+                all: "all";
+            }>>;
+            pins: z.ZodOptional<z.ZodEnum<{
+                admins: "admins";
+                all: "all";
+            }>>;
+            cid: z.ZodString;
+        }, z.core.$strict>;
+        result: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+        errors: readonly ["invalid_request", "forbidden", "not_found", "too_large", "internal", "no_identity", "unknown_session", "grant_required", "grant_invalid", "directory_unavailable", "directory_inconsistent", "invalid_state", "conv_conflict", "stale_epoch", "relay_unavailable", "rate_limited", "duplicate", "secret_refused", "refused", "declined", "request_required", "loop_guard", "unknown_device", "binding_invalid"];
+    };
+    readonly "conv.meta": {
+        params: z.ZodObject<{
+            meta: z.ZodObject<{
+                name: z.ZodOptional<z.ZodString>;
+                topic: z.ZodOptional<z.ZodString>;
+                purpose: z.ZodOptional<z.ZodString>;
+            }, z.core.$strict>;
+            cid: z.ZodString;
+        }, z.core.$strict>;
+        result: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+        errors: readonly ["invalid_request", "forbidden", "not_found", "too_large", "internal", "no_identity", "unknown_session", "grant_required", "grant_invalid", "directory_unavailable", "directory_inconsistent", "invalid_state", "conv_conflict", "stale_epoch", "relay_unavailable", "rate_limited", "duplicate", "secret_refused", "refused", "declined", "request_required", "loop_guard", "unknown_device", "binding_invalid"];
+    };
+    readonly "conv.archive": {
+        params: z.ZodObject<{
+            on: z.ZodBoolean;
+            cid: z.ZodString;
+        }, z.core.$strict>;
+        result: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+        errors: readonly ["invalid_request", "forbidden", "not_found", "too_large", "internal", "no_identity", "unknown_session", "grant_required", "grant_invalid", "directory_unavailable", "directory_inconsistent", "invalid_state", "conv_conflict", "stale_epoch", "relay_unavailable", "rate_limited", "duplicate", "secret_refused", "refused", "declined", "request_required", "loop_guard", "unknown_device", "binding_invalid"];
+    };
+    readonly "conv.leave": {
+        params: z.ZodObject<{
+            cid: z.ZodString;
+        }, z.core.$strict>;
+        result: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+        errors: readonly ["invalid_request", "forbidden", "not_found", "too_large", "internal", "no_identity", "unknown_session", "grant_required", "grant_invalid", "directory_unavailable", "directory_inconsistent", "invalid_state", "conv_conflict", "stale_epoch", "relay_unavailable", "rate_limited", "duplicate", "secret_refused", "refused", "declined", "request_required", "loop_guard", "unknown_device", "binding_invalid"];
+    };
+    readonly "conv.join": {
+        params: z.ZodObject<{
+            cid: z.ZodString;
+        }, z.core.$strict>;
+        result: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+        errors: readonly ["invalid_request", "forbidden", "not_found", "too_large", "internal", "no_identity", "unknown_session", "grant_required", "grant_invalid", "directory_unavailable", "directory_inconsistent", "invalid_state", "conv_conflict", "stale_epoch", "relay_unavailable", "rate_limited", "duplicate", "secret_refused", "refused", "declined", "request_required", "loop_guard", "unknown_device", "binding_invalid"];
+    };
+    readonly "conv.accept": {
+        params: z.ZodObject<{
+            cid: z.ZodString;
+        }, z.core.$strict>;
+        result: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+        errors: readonly ["invalid_request", "forbidden", "not_found", "too_large", "internal", "no_identity", "unknown_session", "grant_required", "grant_invalid", "directory_unavailable", "directory_inconsistent", "invalid_state", "conv_conflict", "stale_epoch", "relay_unavailable", "rate_limited", "duplicate", "secret_refused", "refused", "declined", "request_required", "loop_guard", "unknown_device", "binding_invalid"];
+    };
+    readonly "conv.search": {
+        params: z.ZodObject<{
+            limit: z.ZodOptional<z.ZodNumber>;
+            cursor: z.ZodOptional<z.ZodString>;
+            key: z.ZodOptional<z.ZodString>;
+            query: z.ZodString;
+            cid: z.ZodOptional<z.ZodString>;
+            from: z.ZodOptional<z.ZodString>;
+            after: z.ZodOptional<z.ZodNumber>;
+            before: z.ZodOptional<z.ZodNumber>;
+            thread: z.ZodOptional<z.ZodString>;
+            has: z.ZodOptional<z.ZodEnum<{
+                file: "file";
+                link: "link";
+            }>>;
+        }, z.core.$strict>;
+        result: z.ZodUnion<readonly [z.ZodObject<{
+            events: z.ZodArray<z.ZodObject<{
+                cid: z.ZodString;
+                id: z.ZodString;
+                seq: z.ZodNumber;
+                at: z.ZodNumber;
+                author: z.ZodObject<{
+                    name: z.ZodString;
+                    kind: z.ZodEnum<{
+                        person: "person";
+                        agent: "agent";
+                    }>;
+                    p: z.ZodString;
+                }, z.core.$strip>;
+                kind: z.ZodEnum<{
+                    task: "task";
+                    line: "line";
+                    notice: "notice";
+                }>;
+                text: z.ZodOptional<z.ZodString>;
+                format: z.ZodOptional<z.ZodEnum<{
+                    plain: "plain";
+                    md: "md";
+                }>>;
+                thread: z.ZodOptional<z.ZodString>;
+                broadcast: z.ZodOptional<z.ZodBoolean>;
+                mentions: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    p: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    all: z.ZodLiteral<"channel">;
+                }, z.core.$strict>, z.ZodObject<{
+                    all: z.ZodLiteral<"here">;
+                }, z.core.$strict>]>>>;
+                mentionsMe: z.ZodBoolean;
+                files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    blob: z.ZodString;
+                    name: z.ZodString;
+                    mime: z.ZodString;
+                    bytes: z.ZodNumber;
+                }, z.core.$strip>>>;
+                edited: z.ZodOptional<z.ZodNumber>;
+                deleted: z.ZodOptional<z.ZodBoolean>;
+                reactions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    key: z.ZodString;
+                    count: z.ZodNumber;
+                    mine: z.ZodBoolean;
+                }, z.core.$strip>>>;
+                pinned: z.ZodOptional<z.ZodBoolean>;
+                replies: z.ZodOptional<z.ZodObject<{
+                    count: z.ZodNumber;
+                    lastAt: z.ZodNumber;
+                    participants: z.ZodArray<z.ZodString>;
+                    unread: z.ZodOptional<z.ZodNumber>;
+                    following: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                task: z.ZodOptional<z.ZodObject<{
+                    id: 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";
+                    }>;
+                }, z.core.$strip>>;
+                notice: z.ZodOptional<z.ZodObject<{
+                    op: z.ZodEnum<{
+                        role: "role";
+                        remove: "remove";
+                        accept: "accept";
+                        settings: "settings";
+                        create: "create";
+                        add: "add";
+                        join: "join";
+                        leave: "leave";
+                        seat: "seat";
+                        archive: "archive";
+                        policy: "policy";
+                        meta: "meta";
+                    }>;
+                    by: z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodEnum<{
+                            person: "person";
+                            agent: "agent";
+                        }>;
+                        p: z.ZodString;
+                    }, z.core.$strip>;
+                    participants: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodEnum<{
+                            person: "person";
+                            agent: "agent";
+                        }>;
+                        p: z.ZodString;
+                    }, z.core.$strip>>>;
+                    fields: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                        name: "name";
+                        history: "history";
+                        purpose: "purpose";
+                        agentContext: "agentContext";
+                        bridges: "bridges";
+                        visibility: "visibility";
+                        retainDays: "retainDays";
+                        post: "post";
+                        invite: "invite";
+                        pins: "pins";
+                        topic: "topic";
+                    }>>>;
+                }, z.core.$strip>>;
+                delivery: z.ZodOptional<z.ZodEnum<{
+                    delivered: "delivered";
+                    read: "read";
+                    pending: "pending";
+                    failed: "failed";
+                    sent: "sent";
+                }>>;
+                clientId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            more: z.ZodBoolean;
+            cursor: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>, z.ZodObject<{
+            stage: z.ZodLiteral<"held">;
+            code: z.ZodEnum<{
+                audience: "audience";
+                context: "context";
+            }>;
+            expect: z.ZodLiteral<"on_consent">;
+        }, z.core.$strip>]>;
+        errors: readonly ["invalid_request", "forbidden", "not_found", "too_large", "internal", "no_identity", "unknown_session", "grant_required", "grant_invalid", "directory_unavailable", "directory_inconsistent", "relay_unavailable"];
+    };
+    readonly "conv.context": {
+        params: z.ZodObject<{
+            event: z.ZodString;
+            before: z.ZodOptional<z.ZodNumber>;
+            after: z.ZodOptional<z.ZodNumber>;
+            cid: z.ZodString;
+            key: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        result: z.ZodUnion<readonly [z.ZodObject<{
+            events: z.ZodArray<z.ZodObject<{
+                cid: z.ZodString;
+                id: z.ZodString;
+                seq: z.ZodNumber;
+                at: z.ZodNumber;
+                author: z.ZodObject<{
+                    name: z.ZodString;
+                    kind: z.ZodEnum<{
+                        person: "person";
+                        agent: "agent";
+                    }>;
+                    p: z.ZodString;
+                }, z.core.$strip>;
+                kind: z.ZodEnum<{
+                    task: "task";
+                    line: "line";
+                    notice: "notice";
+                }>;
+                text: z.ZodOptional<z.ZodString>;
+                format: z.ZodOptional<z.ZodEnum<{
+                    plain: "plain";
+                    md: "md";
+                }>>;
+                thread: z.ZodOptional<z.ZodString>;
+                broadcast: z.ZodOptional<z.ZodBoolean>;
+                mentions: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    p: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    all: z.ZodLiteral<"channel">;
+                }, z.core.$strict>, z.ZodObject<{
+                    all: z.ZodLiteral<"here">;
+                }, z.core.$strict>]>>>;
+                mentionsMe: z.ZodBoolean;
+                files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    blob: z.ZodString;
+                    name: z.ZodString;
+                    mime: z.ZodString;
+                    bytes: z.ZodNumber;
+                }, z.core.$strip>>>;
+                edited: z.ZodOptional<z.ZodNumber>;
+                deleted: z.ZodOptional<z.ZodBoolean>;
+                reactions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    key: z.ZodString;
+                    count: z.ZodNumber;
+                    mine: z.ZodBoolean;
+                }, z.core.$strip>>>;
+                pinned: z.ZodOptional<z.ZodBoolean>;
+                replies: z.ZodOptional<z.ZodObject<{
+                    count: z.ZodNumber;
+                    lastAt: z.ZodNumber;
+                    participants: z.ZodArray<z.ZodString>;
+                    unread: z.ZodOptional<z.ZodNumber>;
+                    following: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                task: z.ZodOptional<z.ZodObject<{
+                    id: 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";
+                    }>;
+                }, z.core.$strip>>;
+                notice: z.ZodOptional<z.ZodObject<{
+                    op: z.ZodEnum<{
+                        role: "role";
+                        remove: "remove";
+                        accept: "accept";
+                        settings: "settings";
+                        create: "create";
+                        add: "add";
+                        join: "join";
+                        leave: "leave";
+                        seat: "seat";
+                        archive: "archive";
+                        policy: "policy";
+                        meta: "meta";
+                    }>;
+                    by: z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodEnum<{
+                            person: "person";
+                            agent: "agent";
+                        }>;
+                        p: z.ZodString;
+                    }, z.core.$strip>;
+                    participants: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodEnum<{
+                            person: "person";
+                            agent: "agent";
+                        }>;
+                        p: z.ZodString;
+                    }, z.core.$strip>>>;
+                    fields: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                        name: "name";
+                        history: "history";
+                        purpose: "purpose";
+                        agentContext: "agentContext";
+                        bridges: "bridges";
+                        visibility: "visibility";
+                        retainDays: "retainDays";
+                        post: "post";
+                        invite: "invite";
+                        pins: "pins";
+                        topic: "topic";
+                    }>>>;
+                }, z.core.$strip>>;
+                delivery: z.ZodOptional<z.ZodEnum<{
+                    delivered: "delivered";
+                    read: "read";
+                    pending: "pending";
+                    failed: "failed";
+                    sent: "sent";
+                }>>;
+                clientId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            root: z.ZodOptional<z.ZodObject<{
+                cid: z.ZodString;
+                id: z.ZodString;
+                seq: z.ZodNumber;
+                at: z.ZodNumber;
+                author: z.ZodObject<{
+                    name: z.ZodString;
+                    kind: z.ZodEnum<{
+                        person: "person";
+                        agent: "agent";
+                    }>;
+                    p: z.ZodString;
+                }, z.core.$strip>;
+                kind: z.ZodEnum<{
+                    task: "task";
+                    line: "line";
+                    notice: "notice";
+                }>;
+                text: z.ZodOptional<z.ZodString>;
+                format: z.ZodOptional<z.ZodEnum<{
+                    plain: "plain";
+                    md: "md";
+                }>>;
+                thread: z.ZodOptional<z.ZodString>;
+                broadcast: z.ZodOptional<z.ZodBoolean>;
+                mentions: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                    p: z.ZodString;
+                }, z.core.$strict>, z.ZodObject<{
+                    all: z.ZodLiteral<"channel">;
+                }, z.core.$strict>, z.ZodObject<{
+                    all: z.ZodLiteral<"here">;
+                }, z.core.$strict>]>>>;
+                mentionsMe: z.ZodBoolean;
+                files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    blob: z.ZodString;
+                    name: z.ZodString;
+                    mime: z.ZodString;
+                    bytes: z.ZodNumber;
+                }, z.core.$strip>>>;
+                edited: z.ZodOptional<z.ZodNumber>;
+                deleted: z.ZodOptional<z.ZodBoolean>;
+                reactions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                    key: z.ZodString;
+                    count: z.ZodNumber;
+                    mine: z.ZodBoolean;
+                }, z.core.$strip>>>;
+                pinned: z.ZodOptional<z.ZodBoolean>;
+                replies: z.ZodOptional<z.ZodObject<{
+                    count: z.ZodNumber;
+                    lastAt: z.ZodNumber;
+                    participants: z.ZodArray<z.ZodString>;
+                    unread: z.ZodOptional<z.ZodNumber>;
+                    following: z.ZodOptional<z.ZodBoolean>;
+                }, z.core.$strip>>;
+                task: z.ZodOptional<z.ZodObject<{
+                    id: 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";
+                    }>;
+                }, z.core.$strip>>;
+                notice: z.ZodOptional<z.ZodObject<{
+                    op: z.ZodEnum<{
+                        role: "role";
+                        remove: "remove";
+                        accept: "accept";
+                        settings: "settings";
+                        create: "create";
+                        add: "add";
+                        join: "join";
+                        leave: "leave";
+                        seat: "seat";
+                        archive: "archive";
+                        policy: "policy";
+                        meta: "meta";
+                    }>;
+                    by: z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodEnum<{
+                            person: "person";
+                            agent: "agent";
+                        }>;
+                        p: z.ZodString;
+                    }, z.core.$strip>;
+                    participants: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodEnum<{
+                            person: "person";
+                            agent: "agent";
+                        }>;
+                        p: z.ZodString;
+                    }, z.core.$strip>>>;
+                    fields: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                        name: "name";
+                        history: "history";
+                        purpose: "purpose";
+                        agentContext: "agentContext";
+                        bridges: "bridges";
+                        visibility: "visibility";
+                        retainDays: "retainDays";
+                        post: "post";
+                        invite: "invite";
+                        pins: "pins";
+                        topic: "topic";
+                    }>>>;
+                }, z.core.$strip>>;
+                delivery: z.ZodOptional<z.ZodEnum<{
+                    delivered: "delivered";
+                    read: "read";
+                    pending: "pending";
+                    failed: "failed";
+                    sent: "sent";
+                }>>;
+                clientId: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>, z.ZodObject<{
+            stage: z.ZodLiteral<"held">;
+            code: z.ZodEnum<{
+                audience: "audience";
+                context: "context";
+            }>;
+            expect: z.ZodLiteral<"on_consent">;
+        }, z.core.$strip>]>;
+        errors: readonly ["invalid_request", "forbidden", "not_found", "too_large", "internal", "no_identity", "unknown_session", "grant_required", "grant_invalid", "directory_unavailable", "directory_inconsistent", "relay_unavailable"];
+    };
+    readonly "conv.access": {
+        params: z.ZodObject<{
+            limit: z.ZodOptional<z.ZodNumber>;
+            cursor: z.ZodOptional<z.ZodString>;
+            key: z.ZodString;
+            cid: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        result: z.ZodObject<{
+            conversations: z.ZodArray<z.ZodObject<{
+                conv: z.ZodObject<{
+                    cid: z.ZodString;
+                    kind: z.ZodEnum<{
+                        self: "self";
+                        channel: "channel";
+                        group: "group";
+                        dm: "dm";
+                    }>;
+                    visibility: z.ZodOptional<z.ZodEnum<{
+                        public: "public";
+                        private: "private";
+                    }>>;
+                    history: z.ZodEnum<{
+                        none: "none";
+                        shared: "shared";
+                    }>;
+                    retainDays: z.ZodNumber;
+                    agentContext: z.ZodEnum<{
+                        none: "none";
+                        members: "members";
+                        seats: "seats";
+                    }>;
+                    name: z.ZodOptional<z.ZodString>;
+                    topic: z.ZodOptional<z.ZodString>;
+                    purpose: z.ZodOptional<z.ZodString>;
+                    archived: z.ZodBoolean;
+                    role: z.ZodEnum<{
+                        admin: "admin";
+                        member: "member";
+                        owner: "owner";
+                        guest: "guest";
+                    }>;
+                    participants: z.ZodNumber;
+                    dmWith: z.ZodOptional<z.ZodObject<{
+                        p: z.ZodString;
+                        kind: z.ZodEnum<{
+                            person: "person";
+                            agent: "agent";
+                        }>;
+                        role: z.ZodEnum<{
+                            admin: "admin";
+                            member: "member";
+                            owner: "owner";
+                            guest: "guest";
+                        }>;
+                        state: z.ZodEnum<{
+                            member: "member";
+                            invited: "invited";
+                        }>;
+                        name: z.ZodString;
+                        handle: z.ZodOptional<z.ZodString>;
+                        org: z.ZodEnum<{
+                            other: "other";
+                            none: "none";
+                            same: "same";
+                        }>;
+                        presence: z.ZodEnum<{
+                            unknown: "unknown";
+                            away: "away";
+                            offline: "offline";
+                            online: "online";
+                        }>;
+                        agentState: z.ZodOptional<z.ZodEnum<{
+                            idle: "idle";
+                            busy: "busy";
+                            kept: "kept";
+                        }>>;
+                        respondTo: z.ZodOptional<z.ZodEnum<{
+                            self: "self";
+                            none: "none";
+                            members: "members";
+                        }>>;
+                    }, z.core.$strip>>;
+                    last: z.ZodOptional<z.ZodObject<{
+                        cid: z.ZodString;
+                        id: z.ZodString;
+                        seq: z.ZodNumber;
+                        at: z.ZodNumber;
+                        author: z.ZodObject<{
+                            name: z.ZodString;
+                            kind: z.ZodEnum<{
+                                person: "person";
+                                agent: "agent";
+                            }>;
+                            p: z.ZodString;
+                        }, z.core.$strip>;
+                        kind: z.ZodEnum<{
+                            task: "task";
+                            line: "line";
+                            notice: "notice";
+                        }>;
+                        text: z.ZodOptional<z.ZodString>;
+                        format: z.ZodOptional<z.ZodEnum<{
+                            plain: "plain";
+                            md: "md";
+                        }>>;
+                        thread: z.ZodOptional<z.ZodString>;
+                        broadcast: z.ZodOptional<z.ZodBoolean>;
+                        mentions: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                            p: z.ZodString;
+                        }, z.core.$strict>, z.ZodObject<{
+                            all: z.ZodLiteral<"channel">;
+                        }, z.core.$strict>, z.ZodObject<{
+                            all: z.ZodLiteral<"here">;
+                        }, z.core.$strict>]>>>;
+                        mentionsMe: z.ZodBoolean;
+                        files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            blob: z.ZodString;
+                            name: z.ZodString;
+                            mime: z.ZodString;
+                            bytes: z.ZodNumber;
+                        }, z.core.$strip>>>;
+                        edited: z.ZodOptional<z.ZodNumber>;
+                        deleted: z.ZodOptional<z.ZodBoolean>;
+                        reactions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            key: z.ZodString;
+                            count: z.ZodNumber;
+                            mine: z.ZodBoolean;
+                        }, z.core.$strip>>>;
+                        pinned: z.ZodOptional<z.ZodBoolean>;
+                        replies: z.ZodOptional<z.ZodObject<{
+                            count: z.ZodNumber;
+                            lastAt: z.ZodNumber;
+                            participants: z.ZodArray<z.ZodString>;
+                            unread: z.ZodOptional<z.ZodNumber>;
+                            following: z.ZodOptional<z.ZodBoolean>;
+                        }, z.core.$strip>>;
+                        task: z.ZodOptional<z.ZodObject<{
+                            id: 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";
+                            }>;
+                        }, z.core.$strip>>;
+                        notice: z.ZodOptional<z.ZodObject<{
+                            op: z.ZodEnum<{
+                                role: "role";
+                                remove: "remove";
+                                accept: "accept";
+                                settings: "settings";
+                                create: "create";
+                                add: "add";
+                                join: "join";
+                                leave: "leave";
+                                seat: "seat";
+                                archive: "archive";
+                                policy: "policy";
+                                meta: "meta";
+                            }>;
+                            by: z.ZodObject<{
+                                name: z.ZodString;
+                                kind: z.ZodEnum<{
+                                    person: "person";
+                                    agent: "agent";
+                                }>;
+                                p: z.ZodString;
+                            }, z.core.$strip>;
+                            participants: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                                name: z.ZodString;
+                                kind: z.ZodEnum<{
+                                    person: "person";
+                                    agent: "agent";
+                                }>;
+                                p: z.ZodString;
+                            }, z.core.$strip>>>;
+                            fields: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                                name: "name";
+                                history: "history";
+                                purpose: "purpose";
+                                agentContext: "agentContext";
+                                bridges: "bridges";
+                                visibility: "visibility";
+                                retainDays: "retainDays";
+                                post: "post";
+                                invite: "invite";
+                                pins: "pins";
+                                topic: "topic";
+                            }>>>;
+                        }, z.core.$strip>>;
+                        delivery: z.ZodOptional<z.ZodEnum<{
+                            delivered: "delivered";
+                            read: "read";
+                            pending: "pending";
+                            failed: "failed";
+                            sent: "sent";
+                        }>>;
+                        clientId: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    headSeq: z.ZodNumber;
+                    readUpTo: z.ZodOptional<z.ZodNumber>;
+                    unread: z.ZodOptional<z.ZodNumber>;
+                    mentions: z.ZodOptional<z.ZodNumber>;
+                    threadsUnread: z.ZodOptional<z.ZodNumber>;
+                    notify: z.ZodOptional<z.ZodEnum<{
+                        none: "none";
+                        all: "all";
+                        mentions: "mentions";
+                    }>>;
+                    mutedUntil: z.ZodOptional<z.ZodNumber>;
+                    draft: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+                reason: z.ZodEnum<{
+                    seat: "seat";
+                    allow: "allow";
+                    ask: "ask";
+                }>;
+                lookbackDays: z.ZodNumber;
+                indexedFrom: z.ZodOptional<z.ZodNumber>;
+                complete: z.ZodBoolean;
+            }, z.core.$strip>>;
+            cursor: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        errors: readonly ["invalid_request", "forbidden", "not_found", "too_large", "internal", "no_identity", "unknown_session", "grant_required", "grant_invalid", "directory_unavailable", "directory_inconsistent", "relay_unavailable"];
+    };
+    readonly "conv.policy": {
+        params: z.ZodObject<{
+            agentContext: z.ZodEnum<{
+                none: "none";
+                members: "members";
+                seats: "seats";
+            }>;
+            cid: z.ZodString;
+        }, z.core.$strict>;
+        result: z.ZodObject<{
+            ok: z.ZodLiteral<true>;
+        }, z.core.$strip>;
+        errors: readonly ["invalid_request", "forbidden", "not_found", "too_large", "internal", "no_identity", "unknown_session", "grant_required", "grant_invalid", "directory_unavailable", "directory_inconsistent", "invalid_state", "conv_conflict", "stale_epoch", "relay_unavailable", "rate_limited", "duplicate", "secret_refused", "refused", "declined", "request_required", "loop_guard", "unknown_device", "binding_invalid"];
+    };
+    readonly "conv.backfill": {
+        readonly params: z.ZodObject<{
+            cid: z.ZodString;
+        }, z.core.$strict>;
+        readonly result: z.ZodObject<{
+            indexedFrom: z.ZodOptional<z.ZodNumber>;
+            complete: z.ZodBoolean;
+        }, z.core.$strip>;
+        readonly errors: readonly ["invalid_request", "forbidden", "not_found", "too_large", "internal", "no_identity", "unknown_session", "grant_required", "grant_invalid", "directory_unavailable", "directory_inconsistent", "invalid_state", "conv_conflict", "stale_epoch", "relay_unavailable", "rate_limited", "duplicate", "secret_refused", "refused", "declined", "request_required", "loop_guard", "unknown_device", "binding_invalid"];
+    };
+    readonly "conv.sync": {
+        params: z.ZodObject<{
+            key: z.ZodOptional<z.ZodString>;
+            after: z.ZodOptional<z.ZodNumber>;
+            waitMs: z.ZodOptional<z.ZodNumber>;
+            limit: z.ZodOptional<z.ZodNumber>;
+        }, z.core.$strict>;
+        result: z.ZodObject<{
+            events: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+                type: z.ZodLiteral<"event">;
+                pos: z.ZodNumber;
+                event: z.ZodObject<{
+                    cid: z.ZodString;
+                    id: z.ZodString;
+                    seq: z.ZodNumber;
+                    at: z.ZodNumber;
+                    author: z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodEnum<{
+                            person: "person";
+                            agent: "agent";
+                        }>;
+                        p: z.ZodString;
+                    }, z.core.$strip>;
+                    kind: z.ZodEnum<{
+                        task: "task";
+                        line: "line";
+                        notice: "notice";
+                    }>;
+                    text: z.ZodOptional<z.ZodString>;
+                    format: z.ZodOptional<z.ZodEnum<{
+                        plain: "plain";
+                        md: "md";
+                    }>>;
+                    thread: z.ZodOptional<z.ZodString>;
+                    broadcast: z.ZodOptional<z.ZodBoolean>;
+                    mentions: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                        p: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        all: z.ZodLiteral<"channel">;
+                    }, z.core.$strict>, z.ZodObject<{
+                        all: z.ZodLiteral<"here">;
+                    }, z.core.$strict>]>>>;
+                    mentionsMe: z.ZodBoolean;
+                    files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        blob: z.ZodString;
+                        name: z.ZodString;
+                        mime: z.ZodString;
+                        bytes: z.ZodNumber;
+                    }, z.core.$strip>>>;
+                    edited: z.ZodOptional<z.ZodNumber>;
+                    deleted: z.ZodOptional<z.ZodBoolean>;
+                    reactions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        key: z.ZodString;
+                        count: z.ZodNumber;
+                        mine: z.ZodBoolean;
+                    }, z.core.$strip>>>;
+                    pinned: z.ZodOptional<z.ZodBoolean>;
+                    replies: z.ZodOptional<z.ZodObject<{
+                        count: z.ZodNumber;
+                        lastAt: z.ZodNumber;
+                        participants: z.ZodArray<z.ZodString>;
+                        unread: z.ZodOptional<z.ZodNumber>;
+                        following: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>>;
+                    task: z.ZodOptional<z.ZodObject<{
+                        id: 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";
+                        }>;
+                    }, z.core.$strip>>;
+                    notice: z.ZodOptional<z.ZodObject<{
+                        op: z.ZodEnum<{
+                            role: "role";
+                            remove: "remove";
+                            accept: "accept";
+                            settings: "settings";
+                            create: "create";
+                            add: "add";
+                            join: "join";
+                            leave: "leave";
+                            seat: "seat";
+                            archive: "archive";
+                            policy: "policy";
+                            meta: "meta";
+                        }>;
+                        by: z.ZodObject<{
+                            name: z.ZodString;
+                            kind: z.ZodEnum<{
+                                person: "person";
+                                agent: "agent";
+                            }>;
+                            p: z.ZodString;
+                        }, z.core.$strip>;
+                        participants: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            kind: z.ZodEnum<{
+                                person: "person";
+                                agent: "agent";
+                            }>;
+                            p: z.ZodString;
+                        }, z.core.$strip>>>;
+                        fields: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                            name: "name";
+                            history: "history";
+                            purpose: "purpose";
+                            agentContext: "agentContext";
+                            bridges: "bridges";
+                            visibility: "visibility";
+                            retainDays: "retainDays";
+                            post: "post";
+                            invite: "invite";
+                            pins: "pins";
+                            topic: "topic";
+                        }>>>;
+                    }, z.core.$strip>>;
+                    delivery: z.ZodOptional<z.ZodEnum<{
+                        delivered: "delivered";
+                        read: "read";
+                        pending: "pending";
+                        failed: "failed";
+                        sent: "sent";
+                    }>>;
+                    clientId: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"event.update">;
+                pos: z.ZodNumber;
+                cid: z.ZodString;
+                id: z.ZodString;
+                change: z.ZodEnum<{
+                    task: "task";
+                    edit: "edit";
+                    delete: "delete";
+                    react: "react";
+                    pin: "pin";
+                    replies: "replies";
+                    delivery: "delivery";
+                }>;
+                event: z.ZodObject<{
+                    cid: z.ZodString;
+                    id: z.ZodString;
+                    seq: z.ZodNumber;
+                    at: z.ZodNumber;
+                    author: z.ZodObject<{
+                        name: z.ZodString;
+                        kind: z.ZodEnum<{
+                            person: "person";
+                            agent: "agent";
+                        }>;
+                        p: z.ZodString;
+                    }, z.core.$strip>;
+                    kind: z.ZodEnum<{
+                        task: "task";
+                        line: "line";
+                        notice: "notice";
+                    }>;
+                    text: z.ZodOptional<z.ZodString>;
+                    format: z.ZodOptional<z.ZodEnum<{
+                        plain: "plain";
+                        md: "md";
+                    }>>;
+                    thread: z.ZodOptional<z.ZodString>;
+                    broadcast: z.ZodOptional<z.ZodBoolean>;
+                    mentions: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                        p: z.ZodString;
+                    }, z.core.$strict>, z.ZodObject<{
+                        all: z.ZodLiteral<"channel">;
+                    }, z.core.$strict>, z.ZodObject<{
+                        all: z.ZodLiteral<"here">;
+                    }, z.core.$strict>]>>>;
+                    mentionsMe: z.ZodBoolean;
+                    files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        blob: z.ZodString;
+                        name: z.ZodString;
+                        mime: z.ZodString;
+                        bytes: z.ZodNumber;
+                    }, z.core.$strip>>>;
+                    edited: z.ZodOptional<z.ZodNumber>;
+                    deleted: z.ZodOptional<z.ZodBoolean>;
+                    reactions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                        key: z.ZodString;
+                        count: z.ZodNumber;
+                        mine: z.ZodBoolean;
+                    }, z.core.$strip>>>;
+                    pinned: z.ZodOptional<z.ZodBoolean>;
+                    replies: z.ZodOptional<z.ZodObject<{
+                        count: z.ZodNumber;
+                        lastAt: z.ZodNumber;
+                        participants: z.ZodArray<z.ZodString>;
+                        unread: z.ZodOptional<z.ZodNumber>;
+                        following: z.ZodOptional<z.ZodBoolean>;
+                    }, z.core.$strip>>;
+                    task: z.ZodOptional<z.ZodObject<{
+                        id: 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";
+                        }>;
+                    }, z.core.$strip>>;
+                    notice: z.ZodOptional<z.ZodObject<{
+                        op: z.ZodEnum<{
+                            role: "role";
+                            remove: "remove";
+                            accept: "accept";
+                            settings: "settings";
+                            create: "create";
+                            add: "add";
+                            join: "join";
+                            leave: "leave";
+                            seat: "seat";
+                            archive: "archive";
+                            policy: "policy";
+                            meta: "meta";
+                        }>;
+                        by: z.ZodObject<{
+                            name: z.ZodString;
+                            kind: z.ZodEnum<{
+                                person: "person";
+                                agent: "agent";
+                            }>;
+                            p: z.ZodString;
+                        }, z.core.$strip>;
+                        participants: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            name: z.ZodString;
+                            kind: z.ZodEnum<{
+                                person: "person";
+                                agent: "agent";
+                            }>;
+                            p: z.ZodString;
+                        }, z.core.$strip>>>;
+                        fields: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                            name: "name";
+                            history: "history";
+                            purpose: "purpose";
+                            agentContext: "agentContext";
+                            bridges: "bridges";
+                            visibility: "visibility";
+                            retainDays: "retainDays";
+                            post: "post";
+                            invite: "invite";
+                            pins: "pins";
+                            topic: "topic";
+                        }>>>;
+                    }, z.core.$strip>>;
+                    delivery: z.ZodOptional<z.ZodEnum<{
+                        delivered: "delivered";
+                        read: "read";
+                        pending: "pending";
+                        failed: "failed";
+                        sent: "sent";
+                    }>>;
+                    clientId: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"conv">;
+                pos: z.ZodNumber;
+                conv: z.ZodObject<{
+                    cid: z.ZodString;
+                    kind: z.ZodEnum<{
+                        self: "self";
+                        channel: "channel";
+                        group: "group";
+                        dm: "dm";
+                    }>;
+                    visibility: z.ZodOptional<z.ZodEnum<{
+                        public: "public";
+                        private: "private";
+                    }>>;
+                    history: z.ZodEnum<{
+                        none: "none";
+                        shared: "shared";
+                    }>;
+                    retainDays: z.ZodNumber;
+                    agentContext: z.ZodEnum<{
+                        none: "none";
+                        members: "members";
+                        seats: "seats";
+                    }>;
+                    name: z.ZodOptional<z.ZodString>;
+                    topic: z.ZodOptional<z.ZodString>;
+                    purpose: z.ZodOptional<z.ZodString>;
+                    archived: z.ZodBoolean;
+                    role: z.ZodEnum<{
+                        admin: "admin";
+                        member: "member";
+                        owner: "owner";
+                        guest: "guest";
+                    }>;
+                    participants: z.ZodNumber;
+                    dmWith: z.ZodOptional<z.ZodObject<{
+                        p: z.ZodString;
+                        kind: z.ZodEnum<{
+                            person: "person";
+                            agent: "agent";
+                        }>;
+                        role: z.ZodEnum<{
+                            admin: "admin";
+                            member: "member";
+                            owner: "owner";
+                            guest: "guest";
+                        }>;
+                        state: z.ZodEnum<{
+                            member: "member";
+                            invited: "invited";
+                        }>;
+                        name: z.ZodString;
+                        handle: z.ZodOptional<z.ZodString>;
+                        org: z.ZodEnum<{
+                            other: "other";
+                            none: "none";
+                            same: "same";
+                        }>;
+                        presence: z.ZodEnum<{
+                            unknown: "unknown";
+                            away: "away";
+                            offline: "offline";
+                            online: "online";
+                        }>;
+                        agentState: z.ZodOptional<z.ZodEnum<{
+                            idle: "idle";
+                            busy: "busy";
+                            kept: "kept";
+                        }>>;
+                        respondTo: z.ZodOptional<z.ZodEnum<{
+                            self: "self";
+                            none: "none";
+                            members: "members";
+                        }>>;
+                    }, z.core.$strip>>;
+                    last: z.ZodOptional<z.ZodObject<{
+                        cid: z.ZodString;
+                        id: z.ZodString;
+                        seq: z.ZodNumber;
+                        at: z.ZodNumber;
+                        author: z.ZodObject<{
+                            name: z.ZodString;
+                            kind: z.ZodEnum<{
+                                person: "person";
+                                agent: "agent";
+                            }>;
+                            p: z.ZodString;
+                        }, z.core.$strip>;
+                        kind: z.ZodEnum<{
+                            task: "task";
+                            line: "line";
+                            notice: "notice";
+                        }>;
+                        text: z.ZodOptional<z.ZodString>;
+                        format: z.ZodOptional<z.ZodEnum<{
+                            plain: "plain";
+                            md: "md";
+                        }>>;
+                        thread: z.ZodOptional<z.ZodString>;
+                        broadcast: z.ZodOptional<z.ZodBoolean>;
+                        mentions: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodObject<{
+                            p: z.ZodString;
+                        }, z.core.$strict>, z.ZodObject<{
+                            all: z.ZodLiteral<"channel">;
+                        }, z.core.$strict>, z.ZodObject<{
+                            all: z.ZodLiteral<"here">;
+                        }, z.core.$strict>]>>>;
+                        mentionsMe: z.ZodBoolean;
+                        files: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            blob: z.ZodString;
+                            name: z.ZodString;
+                            mime: z.ZodString;
+                            bytes: z.ZodNumber;
+                        }, z.core.$strip>>>;
+                        edited: z.ZodOptional<z.ZodNumber>;
+                        deleted: z.ZodOptional<z.ZodBoolean>;
+                        reactions: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                            key: z.ZodString;
+                            count: z.ZodNumber;
+                            mine: z.ZodBoolean;
+                        }, z.core.$strip>>>;
+                        pinned: z.ZodOptional<z.ZodBoolean>;
+                        replies: z.ZodOptional<z.ZodObject<{
+                            count: z.ZodNumber;
+                            lastAt: z.ZodNumber;
+                            participants: z.ZodArray<z.ZodString>;
+                            unread: z.ZodOptional<z.ZodNumber>;
+                            following: z.ZodOptional<z.ZodBoolean>;
+                        }, z.core.$strip>>;
+                        task: z.ZodOptional<z.ZodObject<{
+                            id: 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";
+                            }>;
+                        }, z.core.$strip>>;
+                        notice: z.ZodOptional<z.ZodObject<{
+                            op: z.ZodEnum<{
+                                role: "role";
+                                remove: "remove";
+                                accept: "accept";
+                                settings: "settings";
+                                create: "create";
+                                add: "add";
+                                join: "join";
+                                leave: "leave";
+                                seat: "seat";
+                                archive: "archive";
+                                policy: "policy";
+                                meta: "meta";
+                            }>;
+                            by: z.ZodObject<{
+                                name: z.ZodString;
+                                kind: z.ZodEnum<{
+                                    person: "person";
+                                    agent: "agent";
+                                }>;
+                                p: z.ZodString;
+                            }, z.core.$strip>;
+                            participants: z.ZodOptional<z.ZodArray<z.ZodObject<{
+                                name: z.ZodString;
+                                kind: z.ZodEnum<{
+                                    person: "person";
+                                    agent: "agent";
+                                }>;
+                                p: z.ZodString;
+                            }, z.core.$strip>>>;
+                            fields: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                                name: "name";
+                                history: "history";
+                                purpose: "purpose";
+                                agentContext: "agentContext";
+                                bridges: "bridges";
+                                visibility: "visibility";
+                                retainDays: "retainDays";
+                                post: "post";
+                                invite: "invite";
+                                pins: "pins";
+                                topic: "topic";
+                            }>>>;
+                        }, z.core.$strip>>;
+                        delivery: z.ZodOptional<z.ZodEnum<{
+                            delivered: "delivered";
+                            read: "read";
+                            pending: "pending";
+                            failed: "failed";
+                            sent: "sent";
+                        }>>;
+                        clientId: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    headSeq: z.ZodNumber;
+                    readUpTo: z.ZodOptional<z.ZodNumber>;
+                    unread: z.ZodOptional<z.ZodNumber>;
+                    mentions: z.ZodOptional<z.ZodNumber>;
+                    threadsUnread: z.ZodOptional<z.ZodNumber>;
+                    notify: z.ZodOptional<z.ZodEnum<{
+                        none: "none";
+                        all: "all";
+                        mentions: "mentions";
+                    }>>;
+                    mutedUntil: z.ZodOptional<z.ZodNumber>;
+                    draft: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"member">;
+                pos: z.ZodNumber;
+                cid: z.ZodString;
+                participant: z.ZodObject<{
+                    p: z.ZodString;
+                    kind: z.ZodEnum<{
+                        person: "person";
+                        agent: "agent";
+                    }>;
+                    role: z.ZodEnum<{
+                        admin: "admin";
+                        member: "member";
+                        owner: "owner";
+                        guest: "guest";
+                    }>;
+                    state: z.ZodEnum<{
+                        member: "member";
+                        invited: "invited";
+                    }>;
+                    name: z.ZodString;
+                    handle: z.ZodOptional<z.ZodString>;
+                    org: z.ZodEnum<{
+                        other: "other";
+                        none: "none";
+                        same: "same";
+                    }>;
+                    presence: z.ZodEnum<{
+                        unknown: "unknown";
+                        away: "away";
+                        offline: "offline";
+                        online: "online";
+                    }>;
+                    agentState: z.ZodOptional<z.ZodEnum<{
+                        idle: "idle";
+                        busy: "busy";
+                        kept: "kept";
+                    }>>;
+                    respondTo: z.ZodOptional<z.ZodEnum<{
+                        self: "self";
+                        none: "none";
+                        members: "members";
+                    }>>;
+                }, z.core.$strip>;
+                change: z.ZodEnum<{
+                    role: "role";
+                    removed: "removed";
+                    added: "added";
+                    invited: "invited";
+                    seat: "seat";
+                    presence: "presence";
+                }>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"read">;
+                pos: z.ZodNumber;
+                cid: z.ZodString;
+                readUpTo: z.ZodNumber;
+                unread: z.ZodNumber;
+                mentions: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"typing">;
+                cid: z.ZodString;
+                p: z.ZodString;
+                thread: z.ZodOptional<z.ZodString>;
+                until: z.ZodNumber;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"activity">;
+                body: z.ZodObject<{
+                    session: z.ZodString;
+                    turn: z.ZodString;
+                    seq: z.ZodNumber;
+                    source: z.ZodOptional<z.ZodObject<{
+                        item: z.ZodOptional<z.ZodString>;
+                        cid: z.ZodOptional<z.ZodString>;
+                        task: z.ZodOptional<z.ZodString>;
+                    }, z.core.$strip>>;
+                    kind: z.ZodEnum<{
+                        error: "error";
+                        cancelled: "cancelled";
+                        turn_started: "turn_started";
+                        step: "step";
+                        turn_ended: "turn_ended";
+                    }>;
+                    summary: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>;
+            }, z.core.$strip>, z.ZodObject<{
+                type: z.ZodLiteral<"gap">;
+                pos: z.ZodNumber;
+            }, z.core.$strip>], "type">>;
+            pos: z.ZodNumber;
+        }, z.core.$strip>;
+        errors: readonly ["invalid_request", "forbidden", "not_found", "too_large", "internal", "no_identity", "unknown_session", "grant_required", "grant_invalid", "directory_unavailable", "directory_inconsistent", "relay_unavailable"];
+    };
+    readonly "people.get": {
+        params: z.ZodObject<{
+            people: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+        }, z.core.$strict>;
+        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>>;
+            missing: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+        }, z.core.$strip>;
+        errors: readonly ["invalid_request", "forbidden", "not_found", "too_large", "internal", "no_identity", "unknown_session", "grant_required", "grant_invalid", "directory_unavailable", "directory_inconsistent", "relay_unavailable"];
+    };
+    readonly "sessions.list": {
+        params: z.ZodObject<{}, z.core.$strict>;
+        result: z.ZodObject<{
+            sessions: z.ZodArray<z.ZodObject<{
+                agent: z.ZodString;
+                state: z.ZodEnum<{
+                    idle: "idle";
+                    busy: "busy";
+                    kept: "kept";
+                }>;
+                seats: z.ZodArray<z.ZodString>;
+            }, z.core.$strip>>;
+        }, z.core.$strip>;
+        errors: readonly ["invalid_request", "forbidden", "not_found", "too_large", "internal", "no_identity", "unknown_session", "grant_required", "grant_invalid", "directory_unavailable", "directory_inconsistent", "relay_unavailable"];
+    };
+    readonly "request.waiting": {
+        params: z.ZodObject<{
+            limit: z.ZodOptional<z.ZodNumber>;
+            cursor: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>;
+        result: z.ZodObject<{
+            items: z.ZodArray<z.ZodObject<{
+                id: z.ZodString;
+                kind: z.ZodEnum<{
+                    message: "message";
+                    task: "task";
+                    contact: "contact";
+                }>;
+                to: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+                name: z.ZodString;
+                at: z.ZodNumber;
+                cid: z.ZodOptional<z.ZodString>;
+                agent: z.ZodOptional<z.ZodString>;
+                state: z.ZodEnum<{
+                    held: "held";
+                    "pending-delivery": "pending-delivery";
+                }>;
+            }, z.core.$strip>>;
+            cursor: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        errors: readonly ["invalid_request", "forbidden", "not_found", "too_large", "internal", "no_identity", "unknown_session", "grant_required", "grant_invalid", "directory_unavailable", "directory_inconsistent", "relay_unavailable"];
+    };
     readonly "contacts.list": {
         readonly params: z.ZodObject<{
             person: z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
@@ -173,151 +2544,42 @@ export declare const IPC_METHODS: {
                 self: z.ZodBoolean;
                 expect: z.ZodOptional<z.ZodEnum<{
                     kept: "kept";
-                    next_turn: "next_turn";
                     wake: "wake";
+                    next_turn: "next_turn";
                     next_prompt: "next_prompt";
                     on_read: "on_read";
                     offline: "offline";
                 }>>;
             }, z.core.$strip>>;
             conversations: z.ZodArray<z.ZodObject<{
-                conversation: z.ZodString;
+                cid: z.ZodString;
                 kind: z.ZodEnum<{
+                    self: "self";
                     channel: "channel";
+                    group: "group";
                     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>;
+                dmWith: z.ZodOptional<z.ZodString>;
             }, 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";
-                    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";
-                    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";
-                }>>;
+            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<{
+                        request: "request";
+                        open: "open";
+                        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>;
     };
@@ -325,6 +2587,7 @@ export declare const IPC_METHODS: {
         readonly params: z.ZodObject<{
             key: z.ZodString;
             id: z.ZodString;
+            cid: z.ZodOptional<z.ZodString>;
         }, z.core.$strict>;
         readonly result: z.ZodDiscriminatedUnion<[z.ZodObject<{
             kind: z.ZodLiteral<"received">;
@@ -332,12 +2595,14 @@ export declare const IPC_METHODS: {
                 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;
+                    address: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+                    device: z.ZodOptional<z.ZodString>;
+                    label: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>;
+                cid: z.ZodOptional<z.ZodString>;
+                eventId: z.ZodOptional<z.ZodString>;
                 kind: z.ZodEnum<{
                     message: "message";
                     task: "task";
@@ -392,7 +2657,7 @@ export declare const IPC_METHODS: {
         }, 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]>;
+            to: z.ZodString;
             stage: z.ZodEnum<{
                 accepted: "accepted";
                 relayed: "relayed";
@@ -429,6 +2694,7 @@ export declare const IPC_METHODS: {
                     refused: "refused";
                     declined: "declined";
                     request_required: "request_required";
+                    peer_outdated: "peer_outdated";
                     rate_limited: "rate_limited";
                     loop_guard: "loop_guard";
                     too_large: "too_large";
@@ -445,6 +2711,8 @@ export declare const IPC_METHODS: {
                     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";
@@ -459,177 +2727,13 @@ export declare const IPC_METHODS: {
                     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>;
@@ -654,60 +2758,6 @@ export declare const IPC_METHODS: {
             }, 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<{
@@ -724,96 +2774,17 @@ export declare const IPC_METHODS: {
             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">;
+                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 "notice.subscribe": {
         readonly params: z.ZodObject<{
@@ -837,7 +2808,6 @@ export declare const IPC_METHODS: {
                     request: "request";
                     alert: "alert";
                 }>;
-                conversation: z.ZodOptional<z.ZodString>;
                 from: z.ZodOptional<z.ZodObject<{
                     name: z.ZodString;
                     email: z.ZodOptional<z.ZodString>;
@@ -888,7 +2858,6 @@ export declare const IPC_METHODS: {
                 at: z.ZodNumber;
             }, z.core.$strip>>;
             counts: z.ZodObject<{
-                unread: z.ZodNumber;
                 requests: z.ZodNumber;
             }, z.core.$strip>;
         }, z.core.$strip>;
@@ -989,7 +2958,7 @@ export declare const IPC_METHODS: {
             subject: z.ZodOptional<z.ZodUnion<readonly [z.ZodObject<{
                 person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
             }, z.core.$strict>, z.ZodObject<{
-                channel: z.ZodString;
+                conv: z.ZodString;
             }, z.core.$strict>]>>;
         }, z.core.$strict>;
         readonly result: z.ZodObject<{
@@ -1008,31 +2977,29 @@ export declare const IPC_METHODS: {
                     blocked: "blocked";
                 }>>;
                 ask: z.ZodOptional<z.ZodEnum<{
-                    open: "open";
                     request: "request";
+                    open: "open";
                     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.$strict>, z.ZodObject<{
+                    conv: z.ZodString;
+                }, z.core.$strict>]>;
             }, 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>]>;
+                }, z.core.$strict>, z.ZodObject<{
+                    conv: z.ZodString;
+                }, z.core.$strict>]>;
                 chat: z.ZodOptional<z.ZodLiteral<"open">>;
                 agentMail: z.ZodOptional<z.ZodLiteral<"open">>;
                 ask: z.ZodOptional<z.ZodEnum<{
-                    open: "open";
                     request: "request";
+                    open: "open";
                 }>>;
                 trustedUntil: z.ZodOptional<z.ZodNumber>;
                 discoverable: z.ZodOptional<z.ZodLiteral<true>>;
@@ -1053,8 +3020,8 @@ export declare const IPC_METHODS: {
                 blocked: "blocked";
             }>>;
             ask: z.ZodOptional<z.ZodEnum<{
-                open: "open";
                 request: "request";
+                open: "open";
                 no: "no";
             }>>;
             trustedUntil: z.ZodOptional<z.ZodNumber>;
@@ -1062,7 +3029,7 @@ export declare const IPC_METHODS: {
             subject: z.ZodUnion<readonly [z.ZodObject<{
                 person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
             }, z.core.$strict>, z.ZodObject<{
-                channel: z.ZodString;
+                conv: z.ZodString;
             }, z.core.$strict>]>;
         }, z.core.$strict>;
         readonly result: z.ZodObject<{
@@ -1081,18 +3048,17 @@ export declare const IPC_METHODS: {
                     blocked: "blocked";
                 }>>;
                 ask: z.ZodOptional<z.ZodEnum<{
-                    open: "open";
                     request: "request";
+                    open: "open";
                     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.$strict>, z.ZodObject<{
+                    conv: z.ZodString;
+                }, z.core.$strict>]>;
             }, z.core.$strip>;
         }, z.core.$strip>;
     };
@@ -1109,8 +3075,8 @@ export declare const IPC_METHODS: {
                 blocked: "blocked";
             }>>;
             ask: z.ZodOptional<z.ZodEnum<{
-                open: "open";
                 request: "request";
+                open: "open";
                 no: "no";
             }>>;
             trustedUntil: z.ZodOptional<z.ZodNumber>;
@@ -1118,7 +3084,7 @@ export declare const IPC_METHODS: {
             subject: z.ZodUnion<readonly [z.ZodObject<{
                 person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
             }, z.core.$strict>, z.ZodObject<{
-                channel: z.ZodString;
+                conv: z.ZodString;
             }, z.core.$strict>]>;
         }, z.core.$strict>;
         readonly result: z.ZodObject<{
@@ -1148,10 +3114,17 @@ export declare const IPC_METHODS: {
             }, z.core.$strip>, z.ZodObject<{
                 id: z.ZodString;
                 kind: z.ZodLiteral<"contact">;
+                cid: z.ZodOptional<z.ZodString>;
+                state: z.ZodEnum<{
+                    accepted: "accepted";
+                    pending: "pending";
+                    answering: "answering";
+                    resend: "resend";
+                }>;
                 from: z.ZodObject<{
                     person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
                     device: z.ZodString;
-                    label: z.ZodString;
+                    label: z.ZodOptional<z.ZodString>;
                     name: z.ZodString;
                     email: z.ZodOptional<z.ZodString>;
                     org: z.ZodEnum<{
@@ -1169,17 +3142,24 @@ export declare const IPC_METHODS: {
                 agent: z.ZodString;
                 email: z.ZodString;
                 at: z.ZodNumber;
-            }, z.core.$strip>]>>;
+            }, z.core.$strip>, z.ZodObject<{
+                kind: z.ZodLiteral<"agent-invitation">;
+                id: z.ZodString;
+                cid: z.ZodString;
+                from: z.ZodString;
+                to: z.ZodString;
+                at: z.ZodNumber;
+            }, z.core.$strict>]>>;
         }, z.core.$strip>;
     };
     readonly "request.answer": {
         readonly params: z.ZodObject<{
             id: z.ZodString;
             answer: z.ZodEnum<{
-                once: "once";
-                always: "always";
                 accept: "accept";
                 decline: "decline";
+                once: "once";
+                always: "always";
                 block: "block";
             }>;
             all: z.ZodOptional<z.ZodBoolean>;
@@ -1192,10 +3172,10 @@ export declare const IPC_METHODS: {
         readonly params: z.ZodObject<{
             id: z.ZodString;
             answer: z.ZodEnum<{
-                once: "once";
-                always: "always";
                 accept: "accept";
                 decline: "decline";
+                once: "once";
+                always: "always";
                 block: "block";
             }>;
             all: z.ZodOptional<z.ZodBoolean>;
@@ -1205,6 +3185,7 @@ export declare const IPC_METHODS: {
                 message: "message";
                 task: "task";
                 contact: "contact";
+                "agent-invitation": "agent-invitation";
                 suggestion: "suggestion";
             }>;
             from: z.ZodObject<{
@@ -1230,7 +3211,7 @@ export declare const IPC_METHODS: {
         }, z.core.$strict>;
         readonly result: z.ZodObject<{
             id: z.ZodString;
-            conversation: z.ZodString;
+            cid: z.ZodString;
             person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
         }, z.core.$strip>;
     };
@@ -1400,12 +3381,14 @@ export declare const IPC_METHODS: {
                 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;
+                    address: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+                    device: z.ZodOptional<z.ZodString>;
+                    label: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>;
+                cid: z.ZodOptional<z.ZodString>;
+                eventId: z.ZodOptional<z.ZodString>;
                 kind: z.ZodEnum<{
                     message: "message";
                     task: "task";
@@ -1447,6 +3430,7 @@ export declare const IPC_METHODS: {
         readonly params: z.ZodObject<{
             key: z.ZodString;
             id: z.ZodString;
+            cid: z.ZodOptional<z.ZodString>;
             message: z.ZodOptional<z.ZodBoolean>;
         }, z.core.$strict>;
         readonly result: z.ZodObject<{
@@ -1454,12 +3438,14 @@ export declare const IPC_METHODS: {
                 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;
+                    address: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+                    device: z.ZodOptional<z.ZodString>;
+                    label: z.ZodOptional<z.ZodString>;
                 }, z.core.$strip>;
+                cid: z.ZodOptional<z.ZodString>;
+                eventId: z.ZodOptional<z.ZodString>;
                 kind: z.ZodEnum<{
                     message: "message";
                     task: "task";
@@ -1517,6 +3503,7 @@ export declare const IPC_METHODS: {
         readonly params: z.ZodObject<{
             key: z.ZodString;
             id: z.ZodString;
+            cid: z.ZodOptional<z.ZodString>;
             stage: z.ZodEnum<{
                 handed_to_agent: "handed_to_agent";
                 read: "read";
@@ -2265,42 +4252,208 @@ export declare const IPC_METHODS: {
             enc: z.ZodString;
         }, z.core.$strip>;
     };
-    /** Creates a channel with this person and `persons` (at most `LIMITS.channelPersons` together). */
-    readonly "channel.create": {
+    readonly "task.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;
+            onBehalfOf: z.ZodOptional<z.ZodObject<{
+                taskId: z.ZodString;
+                scope: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                maxDepth: z.ZodOptional<z.ZodNumber>;
+            }, z.core.$strict>>;
+            key: z.ZodString;
+            to: 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>>;
+            contextId: 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>;
         }, z.core.$strict>;
         readonly result: z.ZodObject<{
-            ok: z.ZodLiteral<true>;
+            results: z.ZodArray<z.ZodObject<{
+                to: 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";
+                    peer_outdated: "peer_outdated";
+                    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";
+                    wake: "wake";
+                    next_turn: "next_turn";
+                    next_prompt: "next_prompt";
+                    on_read: "on_read";
+                    offline: "offline";
+                }>>;
+            }, z.core.$strip>>;
         }, z.core.$strip>;
     };
-    /** Removes other persons from a channel; only its creator or a team admin may (spec §6.8). */
-    readonly "channel.remove": {
+    readonly "task.continue": {
         readonly params: z.ZodObject<{
-            name: z.ZodString;
-            persons: z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodString]>>;
+            taskId: z.ZodString;
+            key: z.ZodString;
+            to: 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>>;
+            contextId: 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>;
         }, z.core.$strict>;
         readonly result: z.ZodObject<{
-            ok: z.ZodLiteral<true>;
+            results: z.ZodArray<z.ZodObject<{
+                to: 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";
+                    peer_outdated: "peer_outdated";
+                    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";
+                    wake: "wake";
+                    next_turn: "next_turn";
+                    next_prompt: "next_prompt";
+                    on_read: "on_read";
+                    offline: "offline";
+                }>>;
+            }, z.core.$strip>>;
         }, z.core.$strip>;
     };
     readonly "device.status": {
@@ -2375,6 +4528,7 @@ export declare const IPC_METHODS: {
                 }>>;
                 current: z.ZodBoolean;
                 self: z.ZodBoolean;
+                away: z.ZodOptional<z.ZodLiteral<true>>;
                 since: z.ZodOptional<z.ZodNumber>;
                 unbound: z.ZodOptional<z.ZodObject<{
                     at: z.ZodNumber;
@@ -2499,6 +4653,7 @@ export declare const IPC_METHODS: {
                 refused: "refused";
                 declined: "declined";
                 request_required: "request_required";
+                peer_outdated: "peer_outdated";
                 rate_limited: "rate_limited";
                 loop_guard: "loop_guard";
                 too_large: "too_large";
@@ -2515,6 +4670,8 @@ export declare const IPC_METHODS: {
                 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";
@@ -2529,6 +4686,7 @@ export declare const IPC_METHODS: {
                 ticket_invalid: "ticket_invalid";
                 daemon_unavailable: "daemon_unavailable";
                 daemon_mismatch: "daemon_mismatch";
+                store_refused: "store_refused";
                 internal: "internal";
             }>;
             message: z.ZodString;
@@ -2696,14 +4854,14 @@ export type IpcResult<M extends IpcMethod> = z.infer<IpcMethods[M]["result"]>;
  * 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 declare const AGENT_METHODS: readonly ["daemon.status", "daemon.health", "device.status", "device.bind", "session.register", "session.update", "session.unregister", "events.subscribe", "contacts.list", "inbox.list", "inbox.get", "inbox.ack", "item.read", ...ConversationTier<"agent">[], "task.create", "task.continue", "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 declare const HUMAN_METHODS: readonly [...(ConversationTier<"agent"> | ConversationTier<"human">)[], "people.search", "grant.list", "grant.set", "grant.set.preview", "request.list", "request.answer", "request.answer.preview", "contact.request", "contact.request.preview", "card.get", "notice.subscribe", "notice.list", "notice.ack", "device.approve.preview", "device.remove.preview", "identity.replace.preview", "directory.erase.preview"];
 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
@@ -2725,12 +4883,14 @@ export declare const IpcEvent: z.ZodDiscriminatedUnion<[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;
+            address: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+            device: z.ZodOptional<z.ZodString>;
+            label: z.ZodOptional<z.ZodString>;
         }, z.core.$strip>;
+        cid: z.ZodOptional<z.ZodString>;
+        eventId: z.ZodOptional<z.ZodString>;
         kind: z.ZodEnum<{
             message: "message";
             task: "task";
@@ -2789,6 +4949,7 @@ export declare const IpcEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
         refused: "refused";
         declined: "declined";
         request_required: "request_required";
+        peer_outdated: "peer_outdated";
         rate_limited: "rate_limited";
         loop_guard: "loop_guard";
         too_large: "too_large";
@@ -2805,6 +4966,8 @@ export declare const IpcEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
         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";
@@ -2819,6 +4982,7 @@ export declare const IpcEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
         ticket_invalid: "ticket_invalid";
         daemon_unavailable: "daemon_unavailable";
         daemon_mismatch: "daemon_mismatch";
+        store_refused: "store_refused";
         internal: "internal";
     }>>;
 }, z.core.$strip>, z.ZodObject<{
@@ -3004,12 +5168,6 @@ export declare const IpcEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
 }, 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<{
@@ -3036,6 +5194,7 @@ export declare const IpcEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
         refused: "refused";
         declined: "declined";
         request_required: "request_required";
+        peer_outdated: "peer_outdated";
         rate_limited: "rate_limited";
         loop_guard: "loop_guard";
         too_large: "too_large";
@@ -3052,6 +5211,8 @@ export declare const IpcEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
         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";
@@ -3066,6 +5227,7 @@ export declare const IpcEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
         ticket_invalid: "ticket_invalid";
         daemon_unavailable: "daemon_unavailable";
         daemon_mismatch: "daemon_mismatch";
+        store_refused: "store_refused";
         internal: "internal";
     }>>;
 }, z.core.$strip>, z.ZodObject<{
@@ -3077,7 +5239,6 @@ export declare const IpcEvent: z.ZodDiscriminatedUnion<[z.ZodObject<{
             request: "request";
             alert: "alert";
         }>;
-        conversation: z.ZodOptional<z.ZodString>;
         from: z.ZodOptional<z.ZodObject<{
             name: z.ZodString;
             email: z.ZodOptional<z.ZodString>;