agents-can-communicate 0.1.18 → 0.3.0

package/node_modules/@agents-can-communicate/core/src/inbox.mjs

@@ -1,134 +1,118 @@
-import { AccError, EXIT, SCHEMA_VERSION, advanceDelivery, createId, validateRecord }
+import { AccError, EXIT, SCHEMA_VERSION, advanceReceipt }
   from "@agents-can-communicate/protocol";
 
-const receiptId = (messageId, recipient) => `${messageId}--${recipient}`;
-const unresolved = (message, receipt) => receipt.state === "recorded"
-  || receipt.state === "queued"
-  || (message.requiresAck && (receipt.state === "injected" || receipt.state === "seen"));
+import { receiptId, recordMessageInTransaction } from "./conversations.mjs";
+
+const listable = (message, receipt) => receipt.state === "queued" || receipt.state === "offered"
+  || (receipt.state === "retrieved" && message.obligation !== "none");
 
-/** Narrow, recipient-owned message reads and replies. */
 export function createInboxService(ports, sessions) {
   const { store, clock, ids } = ports;
 
   async function requireOpen(input, action) {
-    const existing = await sessions.locateSession(input.sessionId, input.workspaceId);
-    if (existing === null || existing.record.state !== "open"
-      || existing.record.generation !== input.generation) {
+    const located = await sessions.locateSession(input.sessionId, input.workspaceId);
+    if (located === null || located.record.state !== "open"
+      || located.record.generation !== input.generation) {
       throw new AccError(EXIT.CONFLICT, `cannot ${action} from this session generation`,
         { sessionId: input.sessionId });
     }
-    return existing.record;
+    return located.record;
+  }
+
+  function requireOwnedReceipt(tx, session, messageId) {
+    const message = tx.get("message", messageId);
+    const id = receiptId(messageId, session.participantId);
+    const receipt = tx.get("receipt", id);
+    if (message === null || receipt === null) {
+      throw new AccError(EXIT.CONFLICT,
+        "that message is not addressed to this participant",
+        { messageId, participantId: session.participantId });
+    }
+    return { id, message, receipt };
+  }
+
+  function advanceOwned(tx, session, messageId, state, now) {
+    const owned = requireOwnedReceipt(tx, session, messageId);
+    const nextState = advanceReceipt(owned.receipt.state, state);
+    if (nextState === owned.receipt.state) {
+      return { message: owned.message, receipt: owned.receipt };
+    }
+    const receipt = { ...owned.receipt, state: nextState, updatedAt: now };
+    tx.put("receipt", owned.id, receipt, tx.generationOf("receipt", owned.id));
+    tx.append({ schemaVersion: SCHEMA_VERSION, eventId: ids.next("event"),
+      workspaceId: session.workspaceId, actorSessionId: session.sessionId,
+      type: `message.${state}`, occurredAt: now,
+      payload: { messageId, recipientParticipantId: session.participantId } });
+    return { message: owned.message, receipt };
   }
 
   async function readInbox(input) {
     const session = await requireOpen(input, "read the inbox");
-    const snapshot = await store.snapshot(session.workspaceId,
-      { kinds: ["message", "receipt"] });
-    const messages = new Map(snapshot.messages.map(message => [message.messageId, message]));
-    let addressed = snapshot.receipts
-      .filter(receipt => receipt.recipientParticipantId === session.participantId)
-      .map(receipt => ({ message: messages.get(receipt.messageId), receipt }))
-      .filter(item => item.message !== undefined);
-    if (input.messageId !== undefined) {
-      addressed = addressed.filter(item => item.message.messageId === input.messageId
-        && item.receipt.state !== "acknowledged" && item.receipt.state !== "failed");
-      if (addressed.length === 0) {
-        throw new AccError(EXIT.CONFLICT,
-          "that message is not recoverable by this participant",
-          { messageId: input.messageId, participantId: session.participantId });
+    const now = clock.now();
+    return store.transaction(tx => {
+      const messages = new Map(tx.list("message").map(item => [item.messageId, item]));
+      let selected = tx.list("receipt", receipt =>
+        receipt.recipientParticipantId === session.participantId)
+        .filter(receipt => messages.has(receipt.messageId));
+      if (input.messageId === undefined) {
+        selected = selected.filter(receipt => listable(messages.get(receipt.messageId), receipt));
+      } else {
+        selected = selected.filter(receipt => receipt.messageId === input.messageId
+          && receipt.state !== "acknowledged");
+        if (selected.length === 0) {
+          throw new AccError(EXIT.CONFLICT,
+            "that message is not recoverable by this participant",
+            { messageId: input.messageId, participantId: session.participantId });
+        }
       }
-    } else {
-      addressed = addressed.filter(item => unresolved(item.message, item.receipt));
-    }
-    addressed.sort((left, right) => left.message.sentAt.localeCompare(right.message.sentAt)
-      || left.message.messageId.localeCompare(right.message.messageId));
-    if (addressed.length === 0) return [];
+      selected.sort((left, right) => {
+        const a = messages.get(left.messageId);
+        const b = messages.get(right.messageId);
+        return a.sentAt.localeCompare(b.sentAt) || a.messageId.localeCompare(b.messageId);
+      });
+      return selected.map(receipt => advanceOwned(tx, session, receipt.messageId,
+        "retrieved", now));
+    }, { kinds: ["message", "receipt"] });
+  }
 
+  async function acknowledgeMessage(input) {
+    const session = await requireOpen(input, "acknowledge a message");
     const now = clock.now();
-    const shown = [];
-    await store.transaction(async tx => {
-      for (const item of addressed) {
-        const id = receiptId(item.message.messageId, session.participantId);
-        const current = tx.get("receipt", id);
-        const receipt = { ...current, state: advanceDelivery(current.state, "seen"),
-          updatedAt: now };
-        tx.put("receipt", id, receipt, tx.generationOf("receipt", id));
-        tx.append({ schemaVersion: SCHEMA_VERSION, eventId: ids.next("event"),
-          workspaceId: session.workspaceId, actorSessionId: session.sessionId,
-          type: "message.seen", occurredAt: now,
-          payload: { messageId: item.message.messageId,
-            recipientParticipantId: session.participantId } });
-        shown.push({ message: item.message, receipt });
-      }
-    }, { kinds: ["receipt"] });
-    return shown;
+    return store.transaction(tx => advanceOwned(tx, session, input.messageId,
+      "acknowledged", now).receipt,
+    { kinds: ["message", "receipt"] });
   }
 
   async function replyToMessage(input) {
     const session = await requireOpen(input, "reply to a message");
     const now = clock.now();
-    const replyId = createId("message");
-    let result = null;
-    await store.transaction(async tx => {
-      const original = tx.get("message", input.messageId);
-      const ownReceiptId = receiptId(input.messageId, session.participantId);
-      const originalReceipt = tx.get("receipt", ownReceiptId);
-      if (original === null || originalReceipt === null
-        || !original.toParticipantIds.includes(session.participantId)) {
-        throw new AccError(EXIT.CONFLICT,
-          "that message is not addressed to this participant",
-          { messageId: input.messageId, participantId: session.participantId });
-      }
-      if (originalReceipt.state === "acknowledged" || originalReceipt.state === "failed") {
+    const replyId = ids.next("message");
+    return store.transaction(tx => {
+      const original = requireOwnedReceipt(tx, session, input.messageId);
+      const matchingReply = tx.list("message", message =>
+        message.workspaceId === session.workspaceId
+        && message.fromParticipantId === session.participantId
+        && message.clientMessageId === input.clientMessageId).at(0);
+      if (original.receipt.state === "acknowledged" && matchingReply === undefined) {
         throw new AccError(EXIT.CONFLICT, "that message is already resolved",
-          { messageId: input.messageId, state: originalReceipt.state });
+          { messageId: input.messageId });
       }
-      const reply = validateRecord("message", {
-        schemaVersion: SCHEMA_VERSION,
-        messageId: replyId,
-        workspaceId: session.workspaceId,
-        fromSessionId: session.sessionId,
-        fromParticipantId: session.participantId,
-        toParticipantIds: [original.fromParticipantId],
-        type: input.type ?? "answer",
-        subject: input.subject ?? `Re: ${original.subject}`,
-        body: input.body,
-        priority: input.priority ?? "normal",
-        workstreamId: original.workstreamId,
-        taskId: original.taskId,
-        inReplyTo: original.messageId,
-        requiresAck: false,
-        artifacts: input.artifacts ?? [],
-        sentAt: now,
-      });
-      const acknowledged = { ...originalReceipt,
-        state: advanceDelivery(originalReceipt.state, "acknowledged"), updatedAt: now };
-      const replyReceipt = validateRecord("receipt", {
-        schemaVersion: SCHEMA_VERSION,
-        messageId: replyId,
-        workspaceId: session.workspaceId,
-        recipientParticipantId: original.fromParticipantId,
-        state: "queued",
-        updatedAt: now,
-      });
-      tx.put("message", replyId, reply);
-      tx.put("receipt", receiptId(replyId, original.fromParticipantId), replyReceipt);
-      tx.put("receipt", ownReceiptId, acknowledged,
-        tx.generationOf("receipt", ownReceiptId));
-      tx.append({ schemaVersion: SCHEMA_VERSION, eventId: ids.next("event"),
-        workspaceId: session.workspaceId, actorSessionId: session.sessionId,
-        type: "message.sent", occurredAt: now,
-        payload: { messageId: replyId, type: reply.type,
-          recipients: reply.toParticipantIds } });
-      tx.append({ schemaVersion: SCHEMA_VERSION, eventId: ids.next("event"),
-        workspaceId: session.workspaceId, actorSessionId: session.sessionId,
-        type: "message.acknowledged", occurredAt: now,
-        payload: { messageId: original.messageId,
-          recipientParticipantId: session.participantId } });
-      result = { reply, receipt: acknowledged };
-    }, { kinds: ["message", "receipt"] });
-    return result;
+      const recorded = recordMessageInTransaction({ tx, session, now, messageId: replyId, ids,
+        action: "reply to a message", input: {
+          clientMessageId: input.clientMessageId,
+          toParticipantIds: [original.message.fromParticipantId],
+          kind: "answer",
+          obligation: "none",
+          subject: input.subject ?? `Re: ${original.message.subject}`,
+          body: input.body,
+          inReplyTo: original.message.messageId,
+          artifacts: input.artifacts ?? [],
+          handoff: null,
+        } });
+      const receipt = advanceOwned(tx, session, input.messageId, "acknowledged", now).receipt;
+      return { reply: recorded.message, receipt };
+    }, { kinds: ["participant", "session", "message", "receipt"] });
   }
 
-  return { readInbox, replyToMessage };
+  return { readInbox, replyToMessage, acknowledgeMessage };
 }

package/node_modules/@agents-can-communicate/core/src/index.mjs

@@ -3,7 +3,7 @@ export { createCoordinationService } from "./service.mjs";
 export { assertPorts } from "./ports.mjs";
 export { classifySessionPresence } from "./sessions.mjs";
 export { defaultPidIsAlive } from "./pid.mjs";
-export { ATTENTION_PRIORITY, computeAttention } from "./sync.mjs";
-export { looksConsequential, noteNudge } from "./message-signals.mjs";
+export { ATTENTION_PRIORITY, computeAttention } from "./attention.mjs";
+export { SAFE_OFFER_ERROR_CODES } from "./receipts.mjs";
+export { createDeliveryBindingService } from "./delivery-bindings.mjs";
 export { overlaps } from "./claims.mjs";
-export { wouldCycle } from "./tasks.mjs";

package/node_modules/@agents-can-communicate/core/src/intents.mjs

@@ -35,7 +35,6 @@ export function createIntentService(ports, sessions) {
       summary: input.summary,
       mode: input.mode,
       resourceHints: input.resourceHints ?? [],
-      workstreamId: input.workstreamId ?? null,
       state: input.state ?? "active",
       updatedAt: now,
     });

package/node_modules/@agents-can-communicate/core/src/ports.mjs

@@ -8,7 +8,8 @@ import { AccError, EXIT } from "@agents-can-communicate/protocol";
  *   list(kind: string, predicate?: (record: object) => boolean): object[],
  *   put(kind: string, id: string, record: object, expectedGeneration?: string | null): string,
  *   append(event: object): object }} CoordinationTransaction
- * @typedef {{ transaction(callback: (tx: CoordinationTransaction) => unknown): Promise<unknown>,
+ * @typedef {{ transaction(callback: (tx: CoordinationTransaction) => unknown,
+ *   options?: { kinds?: string[], deadlineAt?: number }): Promise<unknown>,
  *   eventsSince(workspaceId: string, cursor: string | null, limit: number): Promise<object>,
  *   snapshot(workspaceId: string): Promise<object> }} CoordinationStore
  */

package/node_modules/@agents-can-communicate/core/src/receipts.mjs

@@ -0,0 +1,109 @@
+import { AccError, EXIT, SCHEMA_VERSION, advanceReceipt }
+  from "@agents-can-communicate/protocol";
+
+import { receiptId } from "./conversations.mjs";
+
+export const SAFE_OFFER_ERROR_CODES = Object.freeze([
+  "ambiguous_recipient_sessions",
+  "delivery_disabled",
+  "recipient_busy",
+  "recipient_unavailable",
+  "transport_error",
+  "transport_rejected",
+  "unsupported_client_version",
+]);
+
+function missingReceipt(messageId, recipientParticipantId) {
+  return new AccError(EXIT.CONFLICT, "no receipt exists for that recipient",
+    { messageId, recipientParticipantId });
+}
+
+function requireReceipt(tx, messageId, recipientParticipantId) {
+  const receipt = tx.get("receipt", receiptId(messageId, recipientParticipantId));
+  if (receipt === null) throw missingReceipt(messageId, recipientParticipantId);
+  const message = tx.get("message", messageId);
+  if (message === null) throw missingReceipt(messageId, recipientParticipantId);
+  return { message, receipt };
+}
+
+function requireOfferableReceipt(tx, input, { allowRoomNextTurn }) {
+  const found = requireReceipt(tx, input.messageId, input.recipientParticipantId);
+  if (found.message.toParticipantIds.length === 0
+    && (!allowRoomNextTurn || input.transport !== "next-turn")) {
+    throw new AccError(EXIT.CONFLICT, "room messages are not eligible for live offers",
+      { messageId: input.messageId, recipientParticipantId: input.recipientParticipantId });
+  }
+  return found.receipt;
+}
+
+function requireTarget(tx, input, { mustBeOpen }) {
+  const target = tx.get("session", input.targetSessionId);
+  if (target === null || (mustBeOpen && target.state !== "open")
+    || target.participantId !== input.recipientParticipantId
+    || target.generation !== input.targetGeneration) {
+    throw new AccError(EXIT.CONFLICT,
+      "the offer target is not this recipient's session generation",
+      { targetSessionId: input.targetSessionId,
+        recipientParticipantId: input.recipientParticipantId });
+  }
+  return target;
+}
+
+export function createReceiptService(ports) {
+  const { store, clock, ids } = ports;
+
+  async function readReceipt(input) {
+    return store.transaction(tx => requireReceipt(tx, input.messageId,
+      input.recipientParticipantId).receipt, { kinds: ["message", "receipt"] });
+  }
+
+  async function recordOfferSucceeded(input) {
+    const now = clock.now();
+    return store.transaction(tx => {
+      const id = receiptId(input.messageId, input.recipientParticipantId);
+      const receipt = requireOfferableReceipt(tx, input, { allowRoomNextTurn: true });
+      const target = requireTarget(tx, input, { mustBeOpen: true });
+      // A retrieval or acknowledgement may win after a transport accepted but
+      // before this transaction acquired the writer. That stronger truth must
+      // remain in place. The same rule makes a repeated successful commit a
+      // read-only operation rather than another success event.
+      if (receipt.state !== "queued") return receipt;
+      const offered = { ...receipt, state: advanceReceipt(receipt.state, "offered"),
+        updatedAt: now };
+      tx.put("receipt", id, offered, tx.generationOf("receipt", id));
+      tx.append({ schemaVersion: SCHEMA_VERSION, eventId: ids.next("event"),
+        workspaceId: receipt.workspaceId, actorSessionId: target.sessionId,
+        type: "message.offer_succeeded", occurredAt: now,
+        payload: { messageId: input.messageId,
+          recipientParticipantId: input.recipientParticipantId,
+          targetSessionId: input.targetSessionId,
+          targetGeneration: input.targetGeneration,
+          transport: input.transport, adapterId: input.adapterId,
+          clientVersion: input.clientVersion } });
+      return offered;
+    }, { kinds: ["session", "message", "receipt"], deadlineAt: input.deadlineAt });
+  }
+
+  async function recordOfferFailed(input) {
+    if (!SAFE_OFFER_ERROR_CODES.includes(input.safeErrorCode)) {
+      throw new AccError(EXIT.DATA, "safeErrorCode is not in the closed offer error set",
+        { safeErrorCode: input.safeErrorCode });
+    }
+    const now = clock.now();
+    return store.transaction(tx => {
+      const receipt = requireOfferableReceipt(tx, input, { allowRoomNextTurn: false });
+      const target = requireTarget(tx, input, { mustBeOpen: false });
+      return tx.append({ schemaVersion: SCHEMA_VERSION, eventId: ids.next("event"),
+        workspaceId: receipt.workspaceId, actorSessionId: target.sessionId,
+        type: "message.offer_failed", occurredAt: now,
+        payload: { messageId: input.messageId,
+          recipientParticipantId: input.recipientParticipantId,
+          targetSessionId: target.sessionId,
+          targetGeneration: target.generation,
+          transport: input.transport, adapterId: input.adapterId,
+          clientVersion: input.clientVersion, safeErrorCode: input.safeErrorCode } });
+    }, { kinds: ["session", "message", "receipt"] });
+  }
+
+  return { readReceipt, recordOfferSucceeded, recordOfferFailed };
+}

package/node_modules/@agents-can-communicate/core/src/service.mjs

@@ -1,14 +1,14 @@
 import { createClaimService } from "./claims.mjs";
-import { createCommunicationService } from "./communication.mjs";
+import { createConversationService } from "./conversations.mjs";
+import { createDeliveryBindingService } from "./delivery-bindings.mjs";
 import { createIntentService } from "./intents.mjs";
 import { createInboxService } from "./inbox.mjs";
 import { defaultPidIsAlive } from "./pid.mjs";
 import { assertPorts } from "./ports.mjs";
+import { createReceiptService } from "./receipts.mjs";
 import { createSessionService } from "./sessions.mjs";
 import { createGuardStateService, createStatusService } from "./status.mjs";
 import { createSyncService } from "./sync.mjs";
-import { createTaskService } from "./tasks.mjs";
-import { createWorkstreamService } from "./workstreams.mjs";
 
 /**
  * Composition root for the domain services. Everything time- or
@@ -29,13 +29,13 @@ export function createCoordinationService({ store, clock, ids,
   const ports = assertPorts({ store, clock, ids, pidIsAlive });
   const sessions = createSessionService(ports);
   const intents = createIntentService(ports, sessions);
-  const workstreams = createWorkstreamService(ports, sessions);
-  const tasks = createTaskService(ports, workstreams);
   const claims = createClaimService(ports, sessions);
-  const communication = createCommunicationService(ports, sessions, claims);
+  const conversations = createConversationService(ports, sessions);
+  const deliveryBindings = createDeliveryBindingService(ports, sessions);
   const inbox = createInboxService(ports, sessions);
+  const receipts = createReceiptService(ports);
   const sync = createSyncService(ports, sessions);
-  const status = createStatusService(ports, sessions);
+  const status = createStatusService(ports, sessions, deliveryBindings);
   const guardState = createGuardStateService(ports);
   return Object.freeze({
     store,
@@ -43,12 +43,23 @@ export function createCoordinationService({ store, clock, ids,
     ids,
     policies: Object.freeze({ ...policies }),
     ...sessions,
+    // Closing a session also retires its live endpoint under the same
+    // generation, so nothing can be offered into a session that has left.
+    closeSession: async input => {
+      const closed = await sessions.closeSession(input);
+      await deliveryBindings.clearDeliveryBinding({ sessionId: input.sessionId,
+        generation: input.generation });
+      return closed;
+    },
     ...intents,
-    ...workstreams,
-    ...tasks,
     ...claims,
-    ...communication,
+    ...conversations,
+    publishDeliveryBinding: deliveryBindings.publishDeliveryBinding,
+    clearDeliveryBinding: deliveryBindings.clearDeliveryBinding,
+    listDeliveryBindings: deliveryBindings.listDeliveryBindings,
+    refreshDeliveryBinding: deliveryBindings.refreshDeliveryBinding,
     ...inbox,
+    ...receipts,
     ...sync,
     ...status,
     guardState,

package/node_modules/@agents-can-communicate/core/src/sessions.mjs

@@ -2,7 +2,6 @@ import { AccError, EXIT, SCHEMA_VERSION, assertPortableId, createId, validateRec
   from "@agents-can-communicate/protocol";
 
 import { ensureMaterialised, isMaterialised, materialise } from "./materialisation.mjs";
-import { writeWorkResponse } from "./notify.mjs";
 
 // A hook-only adapter heartbeats only when its harness gives it a turn, so the
 // staleness window is a multiple of the cadence the session itself declared
@@ -154,7 +153,12 @@ export function createSessionService(ports) {
     // The approved trigger is the SECOND live session, not the first: a lone
     // session must be able to open and close without leaving a trace.
     const live = (await store.ephemeral.list("session")).filter(item => item.state === "open");
-    if (live.length > 1) {
+    // Recheck durable state only after our ephemeral writes. Another process
+    // may have staged the old ephemeral set after our first precheck, committed
+    // materialisation, and retired that set before these puts completed. In
+    // that case this attach is the only ephemeral session left, but it still
+    // has to run the idempotent promotion pass into the now-durable workspace.
+    if (live.length > 1 || await isMaterialised(store, workspaceId)) {
       await materialise(ports, { workspaceId, descriptor: input.descriptor,
         reason: "second_live_session" });
     }
@@ -243,35 +247,33 @@ export function createSessionService(ports) {
 
     await store.transaction(async tx => {
       tx.put("session", sessionId, closed, tx.generationOf("session", sessionId));
-      // Work in progress goes back on the table. A task held by a session that
-      // has gone stayed `in_progress` forever, nobody else could take it, and
-      // whoever asked for it was never told - a request handed to an agent that
-      // closed its terminal simply vanished.
-      for (const task of tx.list("task")) {
-        if (task.assigneeSessionId !== sessionId) continue;
-        if (task.state === "done") continue;
-        const released = { ...task, assigneeSessionId: null, state: "pending" };
-        tx.put("task", task.taskId, released, tx.generationOf("task", task.taskId));
-        writeWorkResponse(tx, { task, actor: closed, workspaceId: closed.workspaceId,
-          now, ids, outcome: "released",
-          reason: "the session working on this closed before finishing it" });
-        tx.append({ schemaVersion: SCHEMA_VERSION, eventId: ids.next("event"),
-          workspaceId: closed.workspaceId, actorSessionId: sessionId,
-          type: "task.released", occurredAt: now, payload: { taskId: task.taskId } });
-      }
       tx.append({ schemaVersion: SCHEMA_VERSION, eventId: ids.next("event"),
         workspaceId: closed.workspaceId, actorSessionId: sessionId, type: "session.closed",
         occurredAt: now, payload: {} });
-    // `writeWorkResponse` tells whoever asked, on this same handle.
-    }, { kinds: ["message", "receipt", "session", "task"] });
+    }, { kinds: ["session"] });
     return closed;
   }
 
+  async function listLiveSessions({ participantId, workspaceId, now = clock.now() }) {
+    const resolved = workspaceId ?? store.workspaceId;
+    const snapshot = resolved === undefined ? null
+      : await store.snapshot(resolved, { kinds: ["workspace", "session"] });
+    const records = snapshot?.workspace === null
+      ? await store.ephemeral.list("session")
+      : snapshot?.sessions ?? await store.ephemeral.list("session");
+    return records
+      .filter(session => session.participantId === participantId
+        && classifySessionPresence(session, now, pidIsAlive) !== "offline")
+      .sort((left, right) => left.sessionId.localeCompare(right.sessionId))
+      .map(session => ({ sessionId: session.sessionId, generation: session.generation }));
+  }
+
   return {
     openSession,
     resumeSession,
     heartbeatSession,
     closeSession,
+    listLiveSessions,
     locateSession: locate,
     ensureMaterialised: options => ensureMaterialised(ports, options),
   };

package/node_modules/@agents-can-communicate/core/src/status.mjs

@@ -1,5 +1,5 @@
 import { classifySessionPresence } from "./sessions.mjs";
-import { computeAttention } from "./sync.mjs";
+import { computeAttention } from "./attention.mjs";
 
 /**
  * Protection level, reported from what is actually enforceable.
@@ -57,7 +57,7 @@ export function createGuardStateService(ports) {
   };
 }
 
-export function createStatusService(ports, sessions) {
+export function createStatusService(ports, sessions, deliveryBindings) {
   const { store, clock, pidIsAlive } = ports;
 
   async function collectStatus(input = {}) {
@@ -85,6 +85,7 @@ export function createStatusService(ports, sessions) {
     const live = classified.filter(item => item.presence !== "offline");
     const claims = snapshot.claims
       .filter(claim => Date.parse(claim.expiresAt) > Date.parse(now));
+    const currentBindings = await deliveryBindings.currentBindings(now);
 
     return {
       workspaceId,
@@ -109,12 +110,6 @@ export function createStatusService(ports, sessions) {
         presence,
         intent: intents.find(intent => intent.sessionId === session.sessionId)?.summary ?? null,
       })),
-      workstreams: snapshot.workstreams.map(workstream => ({
-        workstreamId: workstream.workstreamId,
-        title: workstream.title,
-        state: workstream.state,
-        coordinatorSessionId: workstream.coordinatorSessionId,
-      })),
       // The owner is named twice on purpose. Every command that reaches a peer
       // takes a participant id, so a claim that gave only a session id sent the
       // reader back through the roster to answer "who is holding this, and how
@@ -133,13 +128,20 @@ export function createStatusService(ports, sessions) {
           .find(session => session.sessionId === claim.ownerSessionId)?.participantId ?? null,
         expiresAt: claim.expiresAt,
       })),
+      deliveryBindings: currentBindings.map(({ binding, reachable }) => ({
+        adapterId: binding.adapterId,
+        clientVersion: binding.clientVersion,
+        availableModes: [...binding.availableModes],
+        livePolicy: binding.livePolicy,
+        reachable,
+        leaseUntil: binding.leaseUntil,
+      })),
       attention: computeAttention(snapshot, { session: null,
         participantId: input.participantId, now, pidIsAlive }),
       counts: {
         live: live.length,
         stale: live.filter(item => item.presence === "stale").length,
         claims: claims.length,
-        tasks: snapshot.tasks.length,
         messages: snapshot.messages.length,
       },
     };