@joe-broadhead/messaging 0.7.1 → 0.9.0

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

@@ -95,6 +95,8 @@ export declare const DeviceChangeView: z.ZodObject<{
     at: z.ZodNumber;
 }, z.core.$strip>;
 export type DeviceChangeView = z.infer<typeof DeviceChangeView>;
+/** A presence feature name, such as `tasks`, `conversations` or `reach`. */
+export declare const PresenceFeature: z.ZodString;
 /** One device of this device's person. */
 export declare const DeviceListEntry: z.ZodObject<{
     device: z.ZodString;
@@ -116,6 +118,7 @@ export declare const DeviceListEntry: z.ZodObject<{
     }>>;
     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;
@@ -128,6 +131,7 @@ export declare const DeviceListEntry: z.ZodObject<{
         }>;
         by: z.ZodString;
     }, z.core.$strip>>;
+    features: z.ZodOptional<z.ZodArray<z.ZodString>>;
 }, z.core.$strip>;
 export type DeviceListEntry = z.infer<typeof DeviceListEntry>;
 /** What a link request asks for, and the code to compare. */
@@ -220,6 +224,7 @@ export declare const LoginState: 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";
@@ -237,6 +242,7 @@ export declare const LoginState: z.ZodDiscriminatedUnion<[z.ZodObject<{
         jelly_unavailable: "jelly_unavailable";
         log_conflict: "log_conflict";
         conv_conflict: "conv_conflict";
+        conflict: "conflict";
         stale_epoch: "stale_epoch";
         device_limit: "device_limit";
         admission_required: "admission_required";
@@ -369,6 +375,7 @@ export declare const DEVICE_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;
@@ -381,6 +388,7 @@ export declare const DEVICE_METHODS: {
                     }>;
                     by: z.ZodString;
                 }, z.core.$strip>>;
+                features: z.ZodOptional<z.ZodArray<z.ZodString>>;
             }, z.core.$strip>>;
         }, z.core.$strip>;
     };
@@ -510,6 +518,7 @@ export declare const DEVICE_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";
@@ -527,6 +536,7 @@ export declare const DEVICE_METHODS: {
                 jelly_unavailable: "jelly_unavailable";
                 log_conflict: "log_conflict";
                 conv_conflict: "conv_conflict";
+                conflict: "conflict";
                 stale_epoch: "stale_epoch";
                 device_limit: "device_limit";
                 admission_required: "admission_required";

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

@@ -2,16 +2,16 @@
  * The IPC methods a Jelly host needs (spec §8.2, §8.11; design §13.6, §13.10-§13.12), served in every deployment:
  *
  * - Agent tier: `daemon.health`, a cheap status with no secrets and no counts.
- * - Human tier: `agents.list` and `agents.read` (the person's view of their own agents' traffic on this device),
- *   `notice.subscribe`, `notice.list` and `notice.ack` (notices in fixed categories), and the read-only preview
+ * - Human tier: `notice.subscribe`, `notice.list` and `notice.ack` (notices in fixed categories), and the read-only preview
  *   `device.remove.preview`.
  *
  * Spread into `IPC_METHODS`; `HOST_SCOPE_METHODS` (in `ipc.ts`) is what a host-scope action grant allows.
  */
 import { z } from "zod";
 /**
- * A notice's id, stable per source: `m_<line id>` (a line), `r_<request id>` (a held request), `a_<id>` (an alert).
- * A replay repeats the same ids, so a host rings once.
+ * A notice's id, stable per source: `m_<line id>` (a line), `m_task<task id>` (a task another person's agent asked of
+ * one of this person's agents), `r_<request id>` (a held request), `a_<id>` (an alert). A replay repeats the same ids, so
+ * a host rings once.
  */
 export declare const NoticeId: z.ZodString;
 export type NoticeId = z.infer<typeof NoticeId>;
@@ -64,9 +64,11 @@ export declare const NoticeDevice: z.ZodObject<{
 }, z.core.$strip>;
 export type NoticeDevice = z.infer<typeof NoticeDevice>;
 /**
- * One notice (design §13.11). `message`: a line in a DM or a channel from another person or their agent, or an
- * agent's line to its own person; `request`: a request held for the person; `alert`: an alarm of this device, a
- * change of the person's other devices (with `device`), or trust the person gave that ends within 7 days (with `from`).
+ * One notice (design §13.11). `message`: a line in a DM or a channel from another person or their agent, an
+ * agent's line to its own person, or a task another person's agent asked of one of this person's agents (with `key`
+ * `task:<task id>`, and `from` that person), never a request: it waits on the agent, not the person; `request`: a request
+ * held for the person (an ask held for consent stays one); `alert`: an alarm of this device, a change of the person's
+ * other devices (with `device`), or trust the person gave that ends within 7 days (with `from`).
  * `line` is the first line of a message, through `cleanPeerText`, only when the caller asked for lines; alerts carry
  * fixed text. `from.name` and `from.email` are untrusted text in a hosted realm.
  */
@@ -77,7 +79,6 @@ export declare const Notice: z.ZodObject<{
         request: "request";
         alert: "alert";
     }>;
-    conversation: z.ZodOptional<z.ZodString>;
     from: z.ZodOptional<z.ZodObject<{
         name: z.ZodString;
         email: z.ZodOptional<z.ZodString>;
@@ -125,12 +126,12 @@ export declare const Notice: z.ZodObject<{
             team: "team";
         }>>;
     }, z.core.$strip>>;
+    key: z.ZodOptional<z.ZodString>;
     at: z.ZodNumber;
 }, z.core.$strip>;
 export type Notice = z.infer<typeof Notice>;
-/** What the person's badges count: unread lines in their conversations, and requests held for them. */
+/** What the person's badges count: requests held for them. Conversation read state remains staged. */
 export declare const NoticeCounts: z.ZodObject<{
-    unread: z.ZodNumber;
     requests: z.ZodNumber;
 }, z.core.$strip>;
 /** `daemon.health` (spec §8.2): the daemon's state, with no secrets and no counts. */
@@ -160,18 +161,6 @@ export declare const DaemonHealth: z.ZodObject<{
     storeSchema: z.ZodNumber;
 }, z.core.$strip>;
 export type DaemonHealth = z.infer<typeof DaemonHealth>;
-/** One local agent (a registered or kept session) and its traffic on this device. */
-export declare const AgentSummary: 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>;
 export declare const JELLY_METHODS: {
     /**
      * Agent tier. A cheap status for a host that polls: the daemon's state, the relay, the directory, an alarm, and
@@ -205,92 +194,6 @@ export declare const JELLY_METHODS: {
             storeSchema: z.ZodNumber;
         }, z.core.$strip>;
     };
-    /** Human tier. This person's local agents on this device, most recent first. Read-only. */
-    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>;
-    };
-    /**
-     * Human tier. One local agent's traffic: without `conversation`, the other agents it has mail or tasks with, most
-     * recent first; with `conversation` (`agent:<person>/<agent>`), a page of its entries, as `conv.read` gives them to
-     * the agent, latest first unless `before` names an entry. Changes no stage and sends no receipt. Peer text is
-     * untrusted: a client cleans it for display.
-     */
-    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">;
-    };
     /**
      * Human tier; host scope in `deployment: "jelly"`. Replays the unacknowledged notices after `after` (all of them
      * without it), oldest first, as `notice` events on this connection, then sends each new one. With `lines`, a
@@ -319,7 +222,6 @@ export declare const JELLY_METHODS: {
                     request: "request";
                     alert: "alert";
                 }>;
-                conversation: z.ZodOptional<z.ZodString>;
                 from: z.ZodOptional<z.ZodObject<{
                     name: z.ZodString;
                     email: z.ZodOptional<z.ZodString>;
@@ -367,10 +269,10 @@ export declare const JELLY_METHODS: {
                         team: "team";
                     }>>;
                 }, z.core.$strip>>;
+                key: z.ZodOptional<z.ZodString>;
                 at: z.ZodNumber;
             }, z.core.$strip>>;
             counts: z.ZodObject<{
-                unread: z.ZodNumber;
                 requests: z.ZodNumber;
             }, z.core.$strip>;
         }, z.core.$strip>;
@@ -414,7 +316,9 @@ export declare const JELLY_METHODS: {
      * whose own person's mail may wake the host, and the tasks those sessions await (their unfinished requests). The relay
      * presents the ticket once, for such traffic only, while this device is offline (spec §7, "Wake tickets"). `relay`:
      * `armed` once the relay holds it, `pending` while it is not connected (it is sent at the next connection);
-     * `awaiting`: how many task requests the relay may wake for. A directory realm only.
+     * `awaiting`: how many task requests the relay may wake for; `dms`: how many dms the relay may wake for, those whose
+     * other person shares a channel with this person and is not blocked or muted (spec §8.11, "Wake tickets"). A
+     * directory realm only.
      */
     readonly "wake.arm": {
         readonly params: z.ZodObject<{
@@ -428,6 +332,7 @@ export declare const JELLY_METHODS: {
                 armed: "armed";
             }>;
             awaiting: z.ZodNumber;
+            dms: z.ZodNumber;
         }, z.core.$strip>;
     };
     /** Admin tier; host scope in `deployment: "jelly"`. The relay forgets this device's wake ticket (`pending` until connected). */

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

@@ -8,6 +8,13 @@ import { z } from "zod";
 /** Opaque, client-chosen session key, stable for the life of a client session, e.g. "opencode:<sessionID>". */
 export declare const SessionKey: z.ZodString;
 export type SessionKey = z.infer<typeof SessionKey>;
+/**
+ * A source-issued action token (spec §8.2, "Action tokens"): 32 random bytes, base64url. The daemon mints one per
+ * action, item and human-tier view, keeps it in memory only, and spends it at its first presentation. Opaque to
+ * clients; never logged.
+ */
+export declare const ActionToken: z.ZodString;
+export type ActionToken = z.infer<typeof ActionToken>;
 /**
  * When the recipient will likely see a message (spec §8.2): a hint from its machine's last presence
  * at send time, never a promise.
@@ -21,8 +28,8 @@ export type SessionKey = z.infer<typeof SessionKey>;
  */
 export declare const SendExpect: z.ZodEnum<{
     kept: "kept";
-    next_turn: "next_turn";
     wake: "wake";
+    next_turn: "next_turn";
     next_prompt: "next_prompt";
     on_read: "on_read";
     offline: "offline";
@@ -52,45 +59,14 @@ export declare const DirectoryEntry: z.ZodObject<{
     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>;
 export type DirectoryEntry = z.infer<typeof DirectoryEntry>;
-/** Chat text, at most `LIMITS.chatChars` UTF-16 code units (`max` would count code points). */
-export declare const ChatText: z.ZodString;
-/**
- * A position in this machine's chat order (spec §6.8): every filed line and every chat change takes
- * the next one. Local: another machine numbers the same line differently. 0 is before the first.
- */
-export declare const ChatSeq: z.ZodNumber;
-export type ChatSeq = z.infer<typeof ChatSeq>;
-/** One transcript line (spec §6.8). `id` is the line's `messageId`, the same on every machine. */
-export declare const ChatLine: 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>;
-export type ChatLine = z.infer<typeof ChatLine>;
 /** The other end of an item or a task: a person's device and, when an agent wrote it, the agent. */
 export declare const PeerRef: z.ZodObject<{
     address: z.ZodString;
@@ -104,12 +80,14 @@ export declare const InboxItem: 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";
@@ -142,8 +120,7 @@ export declare const InboxItem: z.ZodObject<{
 }, z.core.$strip>;
 export type InboxItem = z.infer<typeof InboxItem>;
 /**
- * A message this side sent to continue a task it requested (`msg.send` with `kind: "message"`
- * and the `taskId`), and how far it got, from this daemon's own delivery records (spec §6.3).
+ * A task continuation and its stage from this daemon's own delivery records (spec §6.3).
  */
 export declare const TaskFollowUp: z.ZodObject<{
     envelopeId: z.ZodString;
@@ -163,6 +140,21 @@ export declare const TaskFollowUp: z.ZodObject<{
     at: z.ZodNumber;
 }, z.core.$strip>;
 export type TaskFollowUp = z.infer<typeof TaskFollowUp>;
+/** Most characters of `TaskRecord.signIn.tool`: the executor's words, cleaned and capped like a preview. */
+export declare const TASK_SIGN_IN_TOOL_CHARS: 200;
+/** Most characters of `TaskRecord.refusal.reason`: the executor's words, cleaned and capped like a message request. */
+export declare const TASK_REFUSAL_CHARS: 500;
+/** An id a host's engine chose for its session or its pending approval or question: an opaque, plain identifier. */
+export declare const HostLocalId: z.ZodString;
+/**
+ * The executor host's own pending approval or question that an `AUTH_REQUIRED` or `INPUT_REQUIRED` task waits on
+ * (spec §8.2, "The task view"): set by the person's own client with `task.question`, held in this daemon's memory only.
+ */
+export declare const TaskQuestion: z.ZodObject<{
+    sessionId: z.ZodString;
+    approvalId: z.ZodString;
+}, z.core.$strict>;
+export type TaskQuestion = z.infer<typeof TaskQuestion>;
 export declare const TaskRecord: z.ZodObject<{
     task: z.ZodObject<{
         contextId: z.ZodOptional<z.ZodString>;
@@ -278,16 +270,190 @@ export declare const TaskRecord: z.ZodObject<{
         }>;
         at: z.ZodNumber;
     }, z.core.$strip>>>;
+    agent: z.ZodOptional<z.ZodString>;
+    person: z.ZodOptional<z.ZodObject<{
+        id: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+        name: z.ZodString;
+    }, z.core.$strip>>;
+    org: z.ZodOptional<z.ZodEnum<{
+        other: "other";
+        none: "none";
+        same: "same";
+    }>>;
+    signIn: z.ZodOptional<z.ZodObject<{
+        tool: z.ZodOptional<z.ZodString>;
+        by: z.ZodEnum<{
+            you: "you";
+            them: "them";
+        }>;
+    }, z.core.$strip>>;
+    refusal: z.ZodOptional<z.ZodObject<{
+        reason: z.ZodString;
+    }, z.core.$strip>>;
+    question: z.ZodOptional<z.ZodObject<{
+        sessionId: z.ZodString;
+        approvalId: z.ZodString;
+    }, z.core.$strict>>;
 }, z.core.$strip>;
 export type TaskRecord = z.infer<typeof TaskRecord>;
 /**
- * Where a send went (`msg.send`, spec §8.2): an agent session `person/agent@label`, a person (a line
- * from an agent to them) or `#<channel>` (a post).
+ * One side of a task one of this person's agents on this device is in, as the person's own clients see it (spec §8.2,
+ * "The person's tasks"): the task view without the session key (a bearer credential), with `session` the agent's name
+ * and, on the requester side of a task that has not ended, J2's `cancel` action minted for this view.
  */
-export declare const SendTarget: z.ZodUnion<readonly [z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodString]>, z.ZodString]>;
+export declare const PersonTask: z.ZodObject<{
+    person: z.ZodOptional<z.ZodObject<{
+        id: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+        name: z.ZodString;
+    }, z.core.$strip>>;
+    role: z.ZodEnum<{
+        requester: "requester";
+        executor: "executor";
+    }>;
+    task: z.ZodObject<{
+        contextId: z.ZodOptional<z.ZodString>;
+        status: z.ZodObject<{
+            state: z.ZodEnum<{
+                TASK_STATE_SUBMITTED: "TASK_STATE_SUBMITTED";
+                TASK_STATE_WORKING: "TASK_STATE_WORKING";
+                TASK_STATE_COMPLETED: "TASK_STATE_COMPLETED";
+                TASK_STATE_FAILED: "TASK_STATE_FAILED";
+                TASK_STATE_CANCELED: "TASK_STATE_CANCELED";
+                TASK_STATE_INPUT_REQUIRED: "TASK_STATE_INPUT_REQUIRED";
+                TASK_STATE_REJECTED: "TASK_STATE_REJECTED";
+                TASK_STATE_AUTH_REQUIRED: "TASK_STATE_AUTH_REQUIRED";
+            }>;
+            message: z.ZodOptional<z.ZodObject<{
+                messageId: z.ZodString;
+                contextId: z.ZodOptional<z.ZodString>;
+                taskId: z.ZodOptional<z.ZodString>;
+                role: z.ZodEnum<{
+                    ROLE_USER: "ROLE_USER";
+                    ROLE_AGENT: "ROLE_AGENT";
+                }>;
+                parts: z.ZodArray<z.ZodObject<{
+                    text: z.ZodOptional<z.ZodString>;
+                    raw: z.ZodOptional<z.ZodString>;
+                    url: z.ZodOptional<z.ZodString>;
+                    data: z.ZodOptional<z.ZodUnknown>;
+                    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                    filename: z.ZodOptional<z.ZodString>;
+                    mediaType: z.ZodOptional<z.ZodString>;
+                }, z.core.$strip>>;
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+                referenceTaskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            }, z.core.$strip>>;
+            timestamp: z.ZodOptional<z.ZodString>;
+        }, z.core.$strip>;
+        artifacts: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            artifactId: z.ZodString;
+            name: z.ZodOptional<z.ZodString>;
+            description: z.ZodOptional<z.ZodString>;
+            parts: z.ZodArray<z.ZodObject<{
+                text: z.ZodOptional<z.ZodString>;
+                raw: z.ZodOptional<z.ZodString>;
+                url: z.ZodOptional<z.ZodString>;
+                data: z.ZodOptional<z.ZodUnknown>;
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                filename: z.ZodOptional<z.ZodString>;
+                mediaType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        history: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            messageId: z.ZodString;
+            contextId: z.ZodOptional<z.ZodString>;
+            taskId: z.ZodOptional<z.ZodString>;
+            role: z.ZodEnum<{
+                ROLE_USER: "ROLE_USER";
+                ROLE_AGENT: "ROLE_AGENT";
+            }>;
+            parts: z.ZodArray<z.ZodObject<{
+                text: z.ZodOptional<z.ZodString>;
+                raw: z.ZodOptional<z.ZodString>;
+                url: z.ZodOptional<z.ZodString>;
+                data: z.ZodOptional<z.ZodUnknown>;
+                metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+                filename: z.ZodOptional<z.ZodString>;
+                mediaType: z.ZodOptional<z.ZodString>;
+            }, z.core.$strip>>;
+            metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+            extensions: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            referenceTaskIds: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>>;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+        id: z.ZodString;
+    }, z.core.$strip>;
+    org: z.ZodOptional<z.ZodEnum<{
+        other: "other";
+        none: "none";
+        same: "same";
+    }>>;
+    agent: z.ZodOptional<z.ZodString>;
+    chain: z.ZodOptional<z.ZodObject<{
+        addresses: z.ZodArray<z.ZodString>;
+        depth: z.ZodNumber;
+        maxDepth: z.ZodNumber;
+        scope: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        exp: z.ZodNumber;
+    }, z.core.$strip>>;
+    peer: z.ZodObject<{
+        address: z.ZodString;
+        person: z.ZodUnion<readonly [z.ZodString, z.ZodString]>;
+        agent: z.ZodOptional<z.ZodString>;
+        device: z.ZodString;
+        label: z.ZodString;
+    }, z.core.$strip>;
+    createdAt: z.ZodNumber;
+    updatedAt: z.ZodNumber;
+    followUps: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        envelopeId: z.ZodString;
+        messageId: z.ZodString;
+        sentAt: z.ZodNumber;
+        stage: z.ZodEnum<{
+            accepted: "accepted";
+            relayed: "relayed";
+            delivered: "delivered";
+            held: "held";
+            handed_to_agent: "handed_to_agent";
+            read: "read";
+            replied: "replied";
+            rejected: "rejected";
+            expired: "expired";
+        }>;
+        at: z.ZodNumber;
+    }, z.core.$strip>>>;
+    signIn: z.ZodOptional<z.ZodObject<{
+        tool: z.ZodOptional<z.ZodString>;
+        by: z.ZodEnum<{
+            you: "you";
+            them: "them";
+        }>;
+    }, z.core.$strip>>;
+    refusal: z.ZodOptional<z.ZodObject<{
+        reason: z.ZodString;
+    }, z.core.$strip>>;
+    question: z.ZodOptional<z.ZodObject<{
+        sessionId: z.ZodString;
+        approvalId: z.ZodString;
+    }, z.core.$strict>>;
+    key: z.ZodOptional<z.ZodNever>;
+    session: z.ZodString;
+    cancel: z.ZodOptional<z.ZodObject<{
+        name: z.ZodLiteral<"cancel">;
+        token: z.ZodString;
+    }, z.core.$strict>>;
+}, z.core.$strip>;
+export type PersonTask = z.infer<typeof PersonTask>;
+/**
+ * Where a retained task envelope went: an agent session `person/agent@label`.
+ */
+export declare const SendTarget: z.ZodString;
 export type SendTarget = z.infer<typeof SendTarget>;
 export declare const SendResult: z.ZodObject<{
-    to: z.ZodUnion<readonly [z.ZodString, z.ZodUnion<readonly [z.ZodString, z.ZodString]>, z.ZodString]>;
+    to: z.ZodString;
     envelopeId: z.ZodString;
     messageId: z.ZodString;
     taskId: z.ZodOptional<z.ZodString>;
@@ -315,6 +481,7 @@ export declare const SendResult: 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";
@@ -332,6 +499,7 @@ export declare const SendResult: z.ZodObject<{
         jelly_unavailable: "jelly_unavailable";
         log_conflict: "log_conflict";
         conv_conflict: "conv_conflict";
+        conflict: "conflict";
         stale_epoch: "stale_epoch";
         device_limit: "device_limit";
         admission_required: "admission_required";
@@ -352,63 +520,11 @@ export declare const SendResult: z.ZodObject<{
     }>>;
     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>;
 export type SendResult = z.infer<typeof SendResult>;
-/** A place in a conversation page (`conv.read`): an entry's time and id. */
-export declare const ConvCursor: z.ZodObject<{
-    at: z.ZodNumber;
-    id: z.ZodString;
-}, z.core.$strict>;
-export type ConvCursor = z.infer<typeof ConvCursor>;
-/**
- * One entry of a conversation between a local session and one other session (spec §8.2
- * `conv.read`): mail either way, or a task either way. `text` is untrusted peer text for incoming
- * mail and for a task the other side asked for; clients frame it as data.
- */
-export declare const ConvEntry: 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>;
-export type ConvEntry = z.infer<typeof ConvEntry>;