@joe-broadhead/messaging 0.7.1 → 0.8.0

package/dist/lib/modules/core/schema/ipc/jelly.js

@@ -2,8 +2,7 @@
  * 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.
@@ -14,8 +13,6 @@ import { WAKE_AGENTS, WAKE_TICKET_BYTES, WakeUrl } from "../directory-frames.js"
 import { Jws } from "../jelly.js";
 import { DeviceKind } from "../directory.js";
 import { DeviceChangeView, DeviceRemoveParams } from "./device.js";
-import { ConvCursor, ConvEntry } from "./shapes.js";
-import { ConversationRef } from "./surfaces.js";
 /**
  * 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.
@@ -46,14 +43,13 @@ export const NoticeDevice = DeviceChangeView.extend({
 export const Notice = z.object({
     id: NoticeId,
     category: z.enum(["message", "request", "alert"]),
-    conversation: ConversationRef.optional(),
     from: z.object({ name: z.string().max(200), email: z.string().max(320).optional(), org: z.enum(["same", "other", "none"]) }).optional(),
     line: z.string().max(NOTICE_LINE_CHARS).optional(),
     device: NoticeDevice.optional(),
     at: Millis,
 });
-/** What the person's badges count: unread lines in their conversations, and requests held for them. */
-export const NoticeCounts = z.object({ unread: z.number().int().nonnegative(), requests: z.number().int().nonnegative() });
+/** What the person's badges count: requests held for them. Conversation read state remains staged. */
+export const NoticeCounts = z.object({ requests: z.number().int().nonnegative() });
 /** `daemon.health` (spec §8.2): the daemon's state, with no secrets and no counts. */
 export const DaemonHealth = z.object({
     state: z.enum(["starting", "running", "stopping"]),
@@ -66,43 +62,12 @@ export const DaemonHealth = z.object({
     version: z.string().max(64),
     storeSchema: z.number().int().positive(),
 });
-/** One local agent (a registered or kept session) and its traffic on this device. */
-export const AgentSummary = z.object({
-    agent: SessionName,
-    /** Other agents it has mail or tasks with. */
-    conversations: z.number().int().nonnegative(),
-    /** Mail it received and has not read. */
-    unread: z.number().int().nonnegative(),
-    lastAt: Millis.optional(),
-    state: z.enum(["idle", "busy", "kept"]),
-});
-const AgentConversation = z.object({ conversation: ConversationRef, unread: z.number().int().nonnegative(), lastAt: Millis });
 export const JELLY_METHODS = {
     /**
      * Agent tier. A cheap status for a host that polls: the daemon's state, the relay, the directory, an alarm, and
      * whether it is busy. No counts: they are the person's (`notice.list`).
      */
     "daemon.health": { params: z.strictObject({}), result: DaemonHealth },
-    /** Human tier. This person's local agents on this device, most recent first. Read-only. */
-    "agents.list": { params: z.strictObject({}), result: z.object({ agents: z.array(AgentSummary) }) },
-    /**
-     * 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.
-     */
-    "agents.read": {
-        params: z.strictObject({
-            agent: SessionName,
-            conversation: ConversationRef.refine((c) => c.startsWith("agent:"), { message: "a conversation with an agent: agent:<person>/<agent>" }).optional(),
-            before: ConvCursor.optional(),
-            limit: z.number().int().min(1).max(100).optional(),
-        }),
-        result: z.discriminatedUnion("kind", [
-            z.object({ kind: z.literal("conversations"), conversations: z.array(AgentConversation) }),
-            z.object({ kind: z.literal("entries"), conversation: ConversationRef, entries: z.array(ConvEntry), more: z.boolean() }),
-        ]),
-    },
     /**
      * 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

package/dist/lib/modules/core/schema/ipc/shapes.js

@@ -5,7 +5,8 @@
  * imports `ipc.ts` (which spreads their tables).
  */
 import { z } from "../../../vendor/zod/index.js";
-import { Task, TaskState } from "../a2a.js";
+import { Task } from "../a2a.js";
+import { ConvId, ParticipantId } from "../conversation.js";
 import { AgentKind, DeliveryStage, DeliveryTier, MachineId, MachineLabel, Millis, PersonId, SessionAddress, SessionName, SessionState, Ulid, LIMITS, } from "../common.js";
 import { DelegationSummary } from "../delegation.js";
 import { ErrorCode } from "../errors.js";
@@ -41,42 +42,10 @@ export const DirectoryEntry = z.object({
     self: z.boolean().describe("true for sessions registered on this machine"),
     /**
      * When a message sent to this session now, with the wake hint set, would likely be seen: the
-     * same `SendExpect` a `msg.send` result carries (spec §8.2). Absent when no presence lists it.
+     * same `SendExpect` a task send result carries (spec §8.2). Absent when no presence lists it.
      */
     expect: SendExpect.optional(),
 });
-/** Chat text, at most `LIMITS.chatChars` UTF-16 code units (`max` would count code points). */
-export const ChatText = z.string().refine((text) => text.length <= LIMITS.chatChars, { message: `at most ${LIMITS.chatChars} UTF-16 code units` });
-/**
- * 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 const ChatSeq = z.number().int().min(0).max(Number.MAX_SAFE_INTEGER);
-/** One transcript line (spec §6.8). `id` is the line's `messageId`, the same on every machine. */
-export const ChatLine = z.object({
-    id: Ulid,
-    /** This machine's filing order of the line: the cursor for `conv.read` paging and `conv.markRead`. */
-    seq: ChatSeq,
-    at: Millis,
-    person: PersonId,
-    /** The sending agent, when an agent posted it; absent on the person's own line. */
-    agent: SessionName.optional(),
-    direction: z.enum(["in", "out"]),
-    body: ChatText,
-    /** The `id` of the thread's first line; absent on a first line. */
-    thread: Ulid.optional(),
-    /**
-     * On a line this machine sent to other persons (spec §6.8): `sent` until every person has a
-     * delivered copy, `delivered` then, `refused` once some person's every copy was rejected or expired.
-     * `held` while every person still to deliver it holds it for their person to answer: a message request
-     * waiting to be accepted (spec §6.9).
-     */
-    state: z.enum(["sent", "held", "delivered", "refused"]).optional(),
-    /** With `refused`: the persons whose every copy was rejected or expired. */
-    refused: z.array(PersonId).max(LIMITS.channelPersons).optional(),
-    /** A line this daemon wrote about a channel change or a refusal of one; its text is the daemon's, never a peer's. */
-    notice: z.literal(true).optional(),
-});
 /** The other end of an item or a task: a person's device and, when an agent wrote it, the agent. */
 export const PeerRef = z.object({
     address: SessionAddress,
@@ -86,9 +55,12 @@ export const PeerRef = z.object({
     label: MachineLabel,
 });
 export const InboxItem = z.object({
-    id: Ulid.describe("envelope id"),
+    id: Ulid.describe("task envelope id, or conversation event id"),
     key: SessionKey,
-    from: PeerRef,
+    from: PeerRef.extend({ address: z.union([SessionAddress, ParticipantId]), device: MachineId.optional(), label: MachineLabel.optional() }),
+    /** A projected line is addressed by this pair. Task envelopes have neither field. */
+    cid: ConvId.optional(),
+    eventId: Ulid.optional(),
     kind: z.enum(["message", "task"]),
     messageId: z.string().min(1).max(128),
     taskId: Ulid.optional(),
@@ -108,10 +80,11 @@ export const InboxItem = z.object({
      * Absent only on items stored before consent.
      */
     consent: z.enum(["self", "guarded", "trusted"]).optional(),
-});
+}).refine((item) => item.cid !== undefined
+    ? item.eventId === item.id && item.kind === "message" && item.taskId === undefined
+    : item.eventId === undefined && PeerRef.safeParse(item.from).success, "a projected line has a matching cid/eventId; an envelope has device provenance");
 /**
- * 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 const TaskFollowUp = z.object({
     envelopeId: Ulid,
@@ -138,10 +111,9 @@ export const TaskRecord = z.object({
     followUps: z.array(TaskFollowUp).min(1).max(LIMITS.taskFollowUps).optional(),
 });
 /**
- * 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).
+ * Where a retained task envelope went: an agent session `person/agent@label`.
  */
-export const SendTarget = z.union([SessionAddress, PersonId, z.string().regex(/^#[a-z][a-z0-9-]{0,31}$/, "#<channel>")]);
+export const SendTarget = SessionAddress;
 export const SendResult = z.object({
     to: SendTarget,
     envelopeId: Ulid,
@@ -153,33 +125,3 @@ export const SendResult = z.object({
     /** Absent when the stage is `rejected` or `expired`, or when no presence lists the session. */
     expect: SendExpect.optional(),
 });
-/** A place in a conversation page (`conv.read`): an entry's time and id. */
-export const ConvCursor = z.strictObject({ at: Millis, id: Ulid });
-/**
- * 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 const ConvEntry = z.object({
-    /** The envelope id (mail) or the task id (task). */
-    id: Ulid,
-    kind: z.enum(["mail", "task"]),
-    /** `in`: from the other session (mail it sent, a task it asked this session to run); `out`: the reverse. */
-    direction: z.enum(["in", "out"]),
-    /** The other session, as this machine knows it. */
-    peer: SessionAddress,
-    /** Mail: received (in) or sent (out). Task: created. */
-    at: Millis,
-    /**
-     * Incoming mail: its preview. Task: the start of its request. Absent on outgoing mail: the
-     * daemon keeps no copy of what it sent.
-     */
-    text: z.string().max(LIMITS.previewChars).optional(),
-    /** Mail that continues a task. */
-    taskId: Ulid.optional(),
-    /** Mail: its stage (incoming: this side's inbox stage; outgoing: how far it got). */
-    stage: DeliveryStage.optional(),
-    /** Task: this session's role and the task's state now. */
-    role: z.enum(["requester", "executor"]).optional(),
-    state: TaskState.optional(),
-});

package/dist/lib/modules/core/schema/ipc/surfaces.js

@@ -1,223 +1,40 @@
-/**
- * The local API's surface methods (spec §8.2; design §7.5): what agents reach through their tools
- * and what people reach through the CLI and the TUI, by conversation.
- *
- * - Agent tier (`run/agent.sock`): `contacts.list`, `msg.send`, `item.read`, `conv.read`, `search`.
- * - Human tier (`run/admin.sock`): `conv.list`, `conv.read`, `conv.markRead`, `conv.subscribe`,
- *   `person.send`, `people.search`, `people.get`.
- *
- * A conversation is named by a `ConversationRef`: `dm:<person>` (this person's DM with another),
- * `channel:<name>` (a channel this person is in, by its local name) or `agent:<person>/<agent>`
- * (a local session's mail and tasks with that agent, on any of the person's devices).
- */
+/** Discovery and task-envelope reads. Conversation methods live in conversations.ts. */
 import { z } from "../../../vendor/zod/index.js";
-import { Message, Part } from "../a2a.js";
-import { Address, DeliveryStage, MachineId, MachineLabel, Millis, PersonId, RoomRef, Ulid, LIMITS } from "../common.js";
-import { DelegationScope } from "../delegation.js";
-import { Email } from "../directory-frames.js";
+import { Message } from "../a2a.js";
+import { DeliveryStage, Millis, PersonId, Ulid } from "../common.js";
 import { ErrorCode } from "../errors.js";
 import { PersonReach } from "./consent.js";
-import { DeviceChangeView } from "./device.js";
-import { ChatLine, ChatSeq, ChatText, ConvCursor, ConvEntry, DirectoryEntry, InboxItem, SendResult, SendTarget, SessionKey } from "./shapes.js";
-/**
- * Max UTF-8 bytes of `msg.send` metadata as JSON. For wire JSON that is its JCS length: JCS only
- * reorders members.
- */
-const METADATA_BYTES = 16_384;
-/** A conversation: `dm:<person>`, `channel:<name>` or `agent:<person>/<agent>`. */
-export const ConversationRef = z
-    .string()
-    .regex(/^(?:dm:(?:[a-z][a-z0-9-]{0,31}|p_[a-z2-7]{26})|channel:[a-z][a-z0-9-]{0,31}|agent:(?:[a-z][a-z0-9-]{0,31}|p_[a-z2-7]{26})\/[a-z0-9][a-z0-9._-]{0,63})$/, "dm:<person>, channel:<name> or agent:<person>/<agent>");
-/** A place in a conversation: a line's `seq` in a DM or a channel, an entry's `{at, id}` with an agent. */
-export const ConvPlace = z.union([ChatSeq, ConvCursor]);
-/** One conversation this person has (DMs with lines, channels it is in) and this device's read state. */
-export const ConvSummary = z.object({
-    conversation: RoomRef,
-    kind: z.enum(["dm", "channel"]),
-    lastAt: Millis.optional(),
-    /** A channel held under a local name (another channel here already had its name) carries its own name. */
-    name: z.string().max(32).optional(),
-    /** The newest line's seq; absent in a channel with no lines. */
-    lastSeq: ChatSeq.optional(),
-    /** 0 when nothing is marked read. */
-    readUpTo: ChatSeq,
-    /** Lines from others after `readUpTo`. */
-    unread: z.number().int().nonnegative(),
+import { ConvId, ConvKind, ParticipantId } from "../conversation.js";
+import { DirectoryEntry, InboxItem, SendTarget, SessionKey } from "./shapes.js";
+/** Verified discovery metadata, without transcript or read-state placeholders. */
+export const ContactConversation = z.strictObject({
+    cid: ConvId, kind: ConvKind, name: z.string().max(200).optional(), dmWith: ParticipantId.optional(),
 });
-/** A person of the realm, as verified (a roster realm: a team person). */
 export const PersonSummary = z.object({
     person: PersonId,
-    /** The display name; a roster realm has only the person name. Untrusted text in a hosted realm. */
     name: z.string().max(200),
-    /** What a person types to address them. */
     handle: z.string().max(64),
-    /** `same`: in this device's person's org (a roster realm: the team). */
     org: z.enum(["same", "other", "none"]),
-    /** The weakest vouch among their current devices. */
     vouched: z.enum(["jelly", "device", "service", "admin"]),
 });
 export const SURFACE_METHODS = {
-    /**
-     * Agent tier. Who this session can reach: every known agent session (`entries`, as `directory.list`
-     * did in 0.1), and this person's conversations with their read state (`conversations`, as
-     * `conv.list` returns them).
-     */
     "contacts.list": {
         params: z.strictObject({ person: PersonId.optional(), includeOffline: z.boolean().optional() }),
-        /**
-         * `reach`: for each other person among `entries` and the DMs, and each person whose card this device holds, what they may
-         * be sent, from their card or the defaults of the relation (spec §6.9, "Contact cards").
-         */
-        result: z.object({ entries: z.array(DirectoryEntry), conversations: z.array(ConvSummary), reach: z.array(PersonReach) }),
+        result: z.object({ entries: z.array(DirectoryEntry), conversations: z.array(ContactConversation), reach: z.array(PersonReach) }),
     },
-    /**
-     * Agent tier. One send from the session `key` (spec §8.2): mail or a task to an agent
-     * (`person/agent[@label]`), a line to a person (`<person>`), or a post to a channel (`#<channel>`).
-     * A line or a post is attributed to the session; it takes one text part of at most
-     * `LIMITS.chatChars`, `kind: "message"`, and `replyTo` as the thread (the thread's first line),
-     * and none of the A2A fields. `idempotencyKey` makes any send idempotent.
-     */
-    "msg.send": {
-        params: z.strictObject({
-            key: SessionKey,
-            to: z.union([Address, z.string().regex(/^#[a-z][a-z0-9-]{0,31}$/, "#<channel>")]),
-            kind: z.enum(["message", "task"]),
-            parts: z.array(Part).min(1).max(LIMITS.partsPerMessage),
-            contextId: z.string().max(128).optional(),
-            taskId: Ulid.optional().describe("for kind=message: the task this message continues (INPUT_REQUIRED replies)"),
-            replyTo: Ulid.optional(),
-            idempotencyKey: z.string().min(1).max(200).optional(),
-            /** A2A passthrough. The daemon generates messageId when omitted and always overwrites metadata[URI.provenance]. */
-            messageId: z.string().min(1).max(128).optional(),
-            metadata: z
-                .record(z.string(), z.unknown())
-                .refine((m) => new TextEncoder().encode(JSON.stringify(m)).length <= METADATA_BYTES, { message: `metadata is limited to ${METADATA_BYTES} bytes of JSON` })
-                .optional(),
-            extensions: z.array(z.string().min(1).max(256)).max(16).optional(),
-            referenceTaskIds: z.array(Ulid).max(16).optional(),
-            wake: z.boolean().optional().describe("hint that the recipient may wake an idle session; default true"),
-            /**
-             * Only on a line to the session's own person (`<own person>`, spec §6.9 "Message requests"): the agent asks its
-             * person to send a message request to this exact email. The daemon files it for the person to answer; only the
-             * person sends the request.
-             */
-            request: z.strictObject({ contact: Email }).optional(),
-            /**
-             * kind=task only (spec §6.7): delegate on behalf of a task this session executes. The daemon extends that
-             * task's chain to each recipient, narrowed to `scope` and `maxDepth` when given. Without it, a task starts a new chain.
-             */
-            onBehalfOf: z
-                .strictObject({
-                taskId: Ulid.describe("a task this session executes"),
-                scope: z.array(DelegationScope).max(LIMITS.delegationScopes).optional().describe("narrow the scope; never wider than the task's"),
-                maxDepth: z.number().int().min(1).max(LIMITS.delegationDepth).optional().describe("narrow the depth; never above the task's"),
-            })
-                .optional(),
-        }),
-        result: z.object({ results: z.array(SendResult) }),
-    },
-    /**
-     * Agent tier. One item of the session `key` by id: something it received (`received`: returns the
-     * full message, marks it read and sends a read receipt, as `inbox.read` did in 0.1), or something
-     * it sent to an agent (`sent`: how far it got, as `message.status` did). `not_found` otherwise.
-     */
+    /** A received item, or the delivery records of a sent task envelope. */
     "item.read": {
-        params: z.strictObject({ key: SessionKey, id: Ulid }),
+        params: z.strictObject({ key: SessionKey, id: Ulid, cid: ConvId.optional() }),
         result: z.discriminatedUnion("kind", [
             z.object({ kind: z.literal("received"), item: InboxItem, message: Message }),
             z.object({
-                kind: z.literal("sent"),
-                envelopeId: Ulid,
-                to: SendTarget,
-                stage: DeliveryStage,
+                kind: z.literal("sent"), envelopeId: Ulid, to: SendTarget, stage: DeliveryStage,
                 history: z.array(z.object({ stage: DeliveryStage, at: Millis, code: ErrorCode.optional(), note: z.string().optional() })),
             }),
         ]),
     },
-    /**
-     * Agent and human tiers. A page of one conversation, oldest first. With no cursor, the latest
-     * `limit` (default 30 with an agent, 50 in a DM or a channel); with `before`, the latest `limit`
-     * before that place; with `after`, the earliest `limit` after it. `more`: entries remain past the
-     * page in the direction read. Changes no stage and sends no receipt.
-     * - `dm:` and `channel:` give `lines`; `thread` narrows to a thread's first line and its replies;
-     *   the cursor is a line's `seq`.
-     * - `agent:<person>/<agent>` needs the session `key` and gives `entries`: mail either way and tasks
-     *   either way between that session and the agent; the cursor is an entry's `{at, id}`.
-     */
-    "conv.read": {
-        params: z
-            .strictObject({
-            key: SessionKey.optional(),
-            conversation: ConversationRef,
-            thread: Ulid.optional(),
-            before: ConvPlace.optional(),
-            after: ConvPlace.optional(),
-            limit: z.number().int().min(1).max(100).optional(),
-        })
-            .refine((p) => p.before === undefined || p.after === undefined, { message: "before and after do not combine" }),
-        result: z.discriminatedUnion("kind", [
-            z.object({ kind: z.literal("lines"), lines: z.array(ChatLine), more: z.boolean() }),
-            z.object({ kind: z.literal("agent"), entries: z.array(ConvEntry), more: z.boolean() }),
-        ]),
-    },
-    /** Agent tier. Full-text search over the DM and channel lines `conv.read` can read, newest first. */
-    search: {
-        params: z.strictObject({ query: z.string().min(1).max(200), conversation: RoomRef.optional(), limit: z.number().int().min(1).max(50).optional() }),
-        result: z.object({ hits: z.array(ChatLine.extend({ conversation: RoomRef })) }),
-    },
-    /**
-     * Human tier. The channels this person is in and the DMs with lines, newest first, at most `limit`
-     * (default 100), each with this device's read state.
-     */
-    "conv.list": {
-        params: z.strictObject({ limit: z.number().int().min(1).max(200).optional() }),
-        result: z.object({ conversations: z.array(ConvSummary) }),
-    },
-    /**
-     * Human tier. Marks a DM or a channel read on this device up to `upTo` (a line's `seq`): the cursor
-     * only moves forward, and never past the newest seq here. Returns the cursor and what is still unread.
-     */
-    "conv.markRead": {
-        params: z.strictObject({ conversation: RoomRef, upTo: ChatSeq }),
-        result: z.object({ readUpTo: ChatSeq, unread: z.number().int().nonnegative() }),
-    },
-    /**
-     * Human tier. `conv` events go only to connections that call this (spec §6.8). With `since` (the
-     * `seq` of the last event the client handled), the daemon first replays one event per line changed
-     * after it, oldest first, or sends none and answers `gap: true` when it cannot replay them all; the
-     * client then reloads with `conv.list` and `conv.read`. `seq` is the newest seq at the call.
-     */
-    "conv.subscribe": { params: z.strictObject({ since: ChatSeq.optional() }), result: z.object({ seq: ChatSeq, gap: z.boolean() }) },
-    /**
-     * Human tier. A line from the person (no agent) to a DM or a channel this person is in. `thread` is
-     * the `id` of the thread's first line. `clientId` makes the call idempotent: a repeat with the same
-     * `clientId` and the same conversation, thread and text returns the first line's result and sends nothing.
-     */
-    "person.send": {
-        params: z.strictObject({
-            conversation: RoomRef,
-            text: ChatText.min(1),
-            thread: Ulid.optional(),
-            clientId: z.string().min(1).max(200).optional(),
-        }),
-        result: z.object({ id: Ulid, conversation: RoomRef }),
-    },
-    /** Human tier. The persons of the realm whose handle starts with `query` (all with none), at most `limit` (default 50). */
     "people.search": {
         params: z.strictObject({ query: z.string().max(100).optional(), limit: z.number().int().min(1).max(200).optional() }),
         result: z.object({ people: z.array(PersonSummary) }),
     },
-    /** Human tier. One person and their current devices, as verified. `not_found` for a person this realm does not know. */
-    "people.get": {
-        params: z.strictObject({ person: PersonId }),
-        /** A device's `away`: its latest presence, still fresh, says no window of the person is visible on it (spec §6.5). */
-        result: PersonSummary.extend({
-            devices: z.array(z.object({ device: MachineId, label: MachineLabel, self: z.boolean(), away: z.literal(true).optional() })),
-            /**
-             * Their devices added, removed or replaced in the last 7 days, newest first, at most 10 (design §2.8: "Bob's
-             * devices changed: added 'bob-vps' (vouched by Jelly ID)"). Absent for this device's own person and when none.
-             */
-            deviceChanges: z.array(DeviceChangeView).max(10).optional(),
-        }),
-    },
 };

package/dist/lib/modules/core/schema/ipc/tasks.js

@@ -0,0 +1,31 @@
+/** Retained task envelopes, independent of conversation lines. */
+import { z } from "../../../vendor/zod/index.js";
+import { Part } from "../a2a.js";
+import { Address, LIMITS, Ulid } from "../common.js";
+import { DelegationScope } from "../delegation.js";
+import { SendResult, SessionKey } from "./shapes.js";
+const fields = {
+    key: SessionKey,
+    to: Address,
+    parts: z.array(Part).min(1).max(LIMITS.partsPerMessage),
+    contextId: z.string().max(128).optional(),
+    replyTo: Ulid.optional(),
+    idempotencyKey: z.string().min(1).max(200).optional(),
+    messageId: z.string().min(1).max(128).optional(),
+    metadata: z.record(z.string(), z.unknown()).refine((m) => new TextEncoder().encode(JSON.stringify(m)).length <= 16_384, { message: "metadata is limited to 16384 bytes of JSON" }).optional(),
+    extensions: z.array(z.string().min(1).max(256)).max(16).optional(),
+    referenceTaskIds: z.array(Ulid).max(16).optional(),
+    wake: z.boolean().optional(),
+};
+const result = z.object({ results: z.array(SendResult) });
+export const TASK_SEND_METHODS = {
+    "task.create": {
+        params: z.strictObject({ ...fields, onBehalfOf: z.strictObject({
+                taskId: Ulid,
+                scope: z.array(DelegationScope).max(LIMITS.delegationScopes).optional(),
+                maxDepth: z.number().int().min(1).max(LIMITS.delegationDepth).optional(),
+            }).optional() }),
+        result,
+    },
+    "task.continue": { params: z.strictObject({ ...fields, taskId: Ulid }), result },
+};

package/dist/lib/modules/core/schema/ipc.js

@@ -15,21 +15,25 @@
  *
  * 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 "../../vendor/zod/index.js";
 import { DEVICE_METHODS, DeviceStatus, LoginPurpose } from "./ipc/device.js";
 import { Artifact, Message, Part, TaskState, TaskStatus } from "./a2a.js";
-import { AgentKind, ChannelName, DeliveryStage, DeliveryTier, EncKey, Hash, MachineId, MachineLabel, MemberRole, Millis, PersonId, PersonName, RelayUrl, RoomRef, SessionAddress, SessionName, SessionState, TeamId, TeamName, Ulid, LIMITS, } from "./common.js";
+import { AgentKind, DeliveryStage, DeliveryTier, EncKey, Hash, MachineId, MachineLabel, MemberRole, Millis, PersonId, PersonName, RelayUrl, SessionAddress, SessionName, SessionState, TeamId, TeamName, Ulid, LIMITS, } from "./common.js";
 import { ErrorCode } from "./errors.js";
-import { ChatSeq, InboxItem, SessionKey, TaskRecord } from "./ipc/shapes.js";
+import { InboxItem, SessionKey, TaskRecord } from "./ipc/shapes.js";
 import { SURFACE_METHODS } from "./ipc/surfaces.js";
 import { Member } from "./roster.js";
 import { CONSENT_METHODS } from "./ipc/consent.js";
 import { JELLY_METHODS, Notice } from "./ipc/jelly.js";
 import { Jws } from "./jelly.js";
+import { LIVE_CONVERSATION_METHODS, CONVERSATION_TIERS } from "./ipc/conversations.js";
+import { TASK_SEND_METHODS } from "./ipc/tasks.js";
+import { ConvId } from "./conversation.js";
+const conversationTier = (tier) => Object.keys(LIVE_CONVERSATION_METHODS)
+    .filter((m) => CONVERSATION_TIERS[m] === tier);
 export * from "./ipc/shapes.js";
 export * from "./ipc/surfaces.js";
 export * from "./ipc/jelly.js";
@@ -120,6 +124,7 @@ export const InviteSummary = z.object({
 /** Method table: name → params/result schemas. The daemon validates params; clients validate results. */
 export const IPC_METHODS = {
     ...DEVICE_METHODS,
+    ...TASK_SEND_METHODS,
     "daemon.status": { params: Empty, result: DaemonStatus },
     /** Human CLI only: replies, then shuts the daemon down cleanly. */
     "daemon.stop": { params: Empty, result: Ok },
@@ -166,11 +171,11 @@ export const IPC_METHODS = {
      * and ack after (`inbox.ack`), so a crash in between leaves the item unread.
      */
     "inbox.get": {
-        params: z.strictObject({ key: SessionKey, id: Ulid, message: z.boolean().optional() }),
+        params: z.strictObject({ key: SessionKey, id: Ulid, cid: ConvId.optional(), message: z.boolean().optional() }),
         result: z.object({ item: InboxItem, message: Message.optional() }),
     },
     "inbox.ack": {
-        params: z.strictObject({ key: SessionKey, id: Ulid, stage: z.enum(["handed_to_agent", "read"]) }),
+        params: z.strictObject({ key: SessionKey, id: Ulid, cid: ConvId.optional(), stage: z.enum(["handed_to_agent", "read"]) }),
         result: Ok,
     },
     "task.list": {
@@ -291,24 +296,10 @@ export const IPC_METHODS = {
      * while they are pending. Private keys stay in the daemon.
      */
     "team.prepare": { params: Empty, result: z.object({ machine: MachineId, enc: EncKey }) },
-    /** Creates a channel with this person and `persons` (at most `LIMITS.channelPersons` together). */
-    "channel.create": {
-        params: z.strictObject({ name: ChannelName, persons: z.array(PersonId).max(LIMITS.channelPersons) }),
-        result: z.object({ id: Ulid, name: ChannelName }),
-    },
-    "channel.invite": {
-        params: z.strictObject({ name: ChannelName, persons: z.array(PersonId).min(1).max(LIMITS.channelPersons) }),
-        result: Ok,
-    },
-    "channel.leave": { params: z.strictObject({ name: ChannelName }), result: Ok },
-    /** Removes other persons from a channel; only its creator or a team admin may (spec §6.8). */
-    "channel.remove": {
-        params: z.strictObject({ name: ChannelName, persons: z.array(PersonId).min(1).max(LIMITS.channelPersons) }),
-        result: Ok,
-    },
     ...CONSENT_METHODS,
     ...JELLY_METHODS,
     ...SURFACE_METHODS,
+    ...LIVE_CONVERSATION_METHODS,
 };
 /**
  * The agent tier (design §7.5): the methods an agent-facing client may call, and exactly what the
@@ -325,13 +316,13 @@ export const AGENT_METHODS = [
     "session.unregister",
     "events.subscribe",
     "contacts.list",
-    "msg.send",
     "inbox.list",
     "inbox.get",
     "inbox.ack",
     "item.read",
-    "conv.read",
-    "search",
+    ...conversationTier("agent"),
+    "task.create",
+    "task.continue",
     "task.list",
     "task.get",
     "task.update",
@@ -343,13 +334,9 @@ export const AGENT_METHODS = [
  * `conv.read` is in both tiers.
  */
 export const HUMAN_METHODS = [
-    "conv.list",
-    "conv.read",
-    "conv.markRead",
-    "conv.subscribe",
-    "person.send",
+    ...conversationTier("human"),
+    ...conversationTier("agent"),
     "people.search",
-    "people.get",
     "grant.list",
     "grant.set",
     "grant.set.preview",
@@ -359,8 +346,6 @@ export const HUMAN_METHODS = [
     "contact.request",
     "contact.request.preview",
     "card.get",
-    "agents.list",
-    "agents.read",
     "notice.subscribe",
     "notice.list",
     "notice.ack",
@@ -368,10 +353,6 @@ export const HUMAN_METHODS = [
     "device.remove.preview",
     "identity.replace.preview",
     "directory.erase.preview",
-    "channel.create",
-    "channel.invite",
-    "channel.leave",
-    "channel.remove",
 ];
 /**
  * The admin tier (design §7.5): this device and the daemon, and in a roster realm the team, on
@@ -434,13 +415,6 @@ export const IpcEvent = z.discriminatedUnion("type", [
     /** What `contacts.list` returns changed: a presence, a session, the roster. */
     z.object({ type: z.literal("contacts") }),
     z.object({ type: z.literal("relay"), connected: z.boolean() }),
-    /**
-     * A line was stored in a DM or a channel, a channel this person is in changed, or the delivery state
-     * of an outgoing line changed. Only for connections that called `conv.subscribe`. The text stays in
-     * the transcript. `seq` rises with every event; a client resumes from the last one it handled
-     * (`conv.subscribe {since}`).
-     */
-    z.object({ type: z.literal("conv"), conversation: RoomRef, id: Ulid, person: PersonId, seq: ChatSeq }),
     /**
      * A device's sign-in through the browser changed state (spec §15.9): its state and, when it failed, the code. Never
      * the code to type, the link or a token; `device.login.status` gives the rest on the admin socket.

package/dist/lib/modules/core/testing.js

@@ -7,7 +7,7 @@ export { encodeTicket } from "./roster.js";
 export { grantHash } from "./delegation.js";
 export { signJellyToken } from "./directory/jelly-issuer.js";
 export { jellyHostDouble } from "./jelly-host-double.js";
-export { sealConvMetaWith, sealConvMsgWith, sealKeySharesWith } from "./conversation/seal.js";
+export { sealConvMetaWith, sealConvMsgWith, sealConvStateWith, sealKeyShareWith } from "./conversation/seal.js";
 /**
  * Narrows a result whose `kind` tells its shape (`item.read`, `conv.read`) to the expected kind, and
  * throws with both kinds named otherwise: `client.call("item.read", p).then(asKind("received"))`.

package/dist/lib/modules/core/version.js

@@ -3,4 +3,4 @@
  * its IPC hello and a client compares it with its own (spec §8.2). A test keeps it equal to the
  * root package.json.
  */
-export const VERSION = "0.7.1";
+export const VERSION = "0.8.0";