agents-can-communicate 0.1.17 → 0.2.0

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,13 +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
@@ -28,12 +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,
@@ -42,10 +44,12 @@ export function createCoordinationService({ store, clock, ids,
     policies: Object.freeze({ ...policies }),
     ...sessions,
     ...intents,
-    ...workstreams,
-    ...tasks,
     ...claims,
-    ...communication,
+    ...conversations,
+    publishDeliveryBinding: deliveryBindings.publishDeliveryBinding,
+    listDeliveryBindings: deliveryBindings.listDeliveryBindings,
+    ...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" });
     }
@@ -179,6 +183,53 @@ export function createSessionService(ports) {
     return beaten;
   }
 
+  /**
+   * Continue the exact session named by a harness binding.
+   *
+   * Some clients emit SessionStart again after compacting their model context.
+   * The binding is already the continuation token: it names both the session
+   * and its generation. Refreshing that record preserves one identity without
+   * pretending an unrelated or closed generation is still ours.
+   *
+   * Returns null when the binding can no longer be resumed, so the hook may
+   * open a genuinely new session. No semantic event is appended: compaction is
+   * not a second agent arriving.
+   */
+  async function resumeSession({ sessionId, workspaceId, generation, ...metadata }) {
+    const resume = current => {
+      if (current === null || current.state !== "open"
+        || current.generation !== generation) return null;
+      return { ...current,
+      pid: metadata.pid ?? null,
+      checkoutRoot: metadata.checkoutRoot ?? current.checkoutRoot,
+      branch: metadata.branch ?? current.branch,
+      enforcement: metadata.enforcement ?? current.enforcement,
+      lifecycle: metadata.lifecycle ?? current.lifecycle,
+      heartbeatCadenceMs: metadata.heartbeatCadenceMs ?? current.heartbeatCadenceMs,
+      heartbeatAt: clock.now(),
+      };
+    };
+
+    // The compare and replacement happen under the ephemeral store's writer
+    // lock. A close or a replacement generation can win before this update or
+    // after it, but can never be overwritten from a record read beforehand.
+    const ephemeral = await store.ephemeral.update("session", sessionId, resume);
+    if (ephemeral !== null) return ephemeral;
+
+    // Re-read and validate inside the durable transaction for the same reason.
+    // Using generationOf only as the put token is insufficient: it protects
+    // the envelope write, not the semantic generation carried by the record.
+    const resolvedWorkspace = workspaceId ?? store.workspaceId;
+    if (resolvedWorkspace === undefined) return null;
+    return store.transaction(async tx => {
+      const current = tx.get("session", sessionId);
+      const resumed = resume(current);
+      if (resumed === null) return null;
+      tx.put("session", sessionId, resumed, tx.generationOf("session", sessionId));
+      return resumed;
+    }, { kinds: ["session"] });
+  }
+
   async function closeSession({ sessionId, workspaceId, generation }) {
     const existing = await locate(sessionId, workspaceId);
     if (existing === null) throw new AccError(EXIT.CONFLICT, "session is not open", { sessionId });
@@ -196,34 +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,
       },
     };

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

@@ -1,19 +1,10 @@
 import { AccError, EXIT } from "@agents-can-communicate/protocol";
 
+import { computeAttention } from "./attention.mjs";
 import { classifySessionPresence } from "./sessions.mjs";
-import { overlaps } from "./claims.mjs";
 
 const DEFAULT_LIMIT = 100;
-
-// The shape every event carries, and the only thing a caller may ask to resume
-// from. `null` means the beginning, which is what a session with no cursor yet
-// has.
 const CURSOR = /^[0-9]{16}$/;
-
-// The two a caller may ask for. An unknown one used to become `delta`, so
-// `--scope ful` answered the one question the full scope exists for - "show me
-// everything, I cannot see the rest of the system" - with a delta carrying no
-// snapshot at all, and the agent concluded there was nothing to see.
 const SCOPES = Object.freeze(["delta", "full"]);
 
 function assertScope(scope) {
@@ -27,263 +18,22 @@ function assertCursor(cursor) {
   if (typeof cursor !== "string" || !CURSOR.test(cursor)) {
     throw new AccError(EXIT.USAGE,
       "a cursor is the 16-digit sequence a previous sync returned; "
-      + "leave it out to start from the beginning",
-      { cursor });
-  }
-}
-
-// Attention is computed from explicit rules, never from a hidden classifier.
-// Lower priority sorts first.
-//
-// Exported so a test can prove every kind listed here is reachable. A fifth
-// entry once sat here with no rule behind it, which read as a feature in review
-// and produced nothing at runtime.
-export const ATTENTION_PRIORITY = Object.freeze({
-  direct_request: 1,
-  claim_conflict: 2,
-  task_unblocked: 3,
-  coordinator_missing: 4,
-  request_stalled: 5,
-  claim_expired: 6,
-  claim_contended: 7,
-});
-
-function directRequests(snapshot, participantId) {
-  const items = [];
-  for (const receipt of snapshot.receipts ?? []) {
-    if (receipt.recipientParticipantId !== participantId) continue;
-    if (receipt.state === "acknowledged" || receipt.state === "failed") continue;
-    const message = (snapshot.messages ?? []).find(item => item.messageId === receipt.messageId);
-    if (message === undefined || !message.requiresAck) continue;
-    items.push({ kind: "direct_request", priority: ATTENTION_PRIORITY.direct_request,
-      sourceId: message.messageId, summary: message.subject });
-  }
-  return items;
-}
-
-/**
- * A claim of yours that has run out.
- *
- * A lease lapses on the clock, and nothing said so. Measured: while it held, a
- * peer's write into the file was refused; three seconds later the same write
- * went through, and the holder's turn was identical before and after. It went on
- * working on a file it believed it had reserved, and everyone else was free to
- * change it.
- *
- * Only for the session that took it, and only while that session is the one
- * asking: a lapsed claim is news to its owner and nobody else's business.
- * Re-claiming refreshes the lease and clears this; releasing it clears it too.
- */
-function expiredClaims(snapshot, session, now) {
-  if (session == null) return [];
-  return (snapshot.claims ?? [])
-    .filter(claim => claim.ownerSessionId === session.sessionId
-      && Date.parse(claim.expiresAt) <= Date.parse(now))
-    .map(claim => ({ kind: "claim_expired", priority: ATTENTION_PRIORITY.claim_expired,
-      sourceId: claim.claimId,
-      summary: `${claim.resource} - your claim has run out, and peers can write to it` }));
-}
-
-function claimConflicts(snapshot, session, now) {
-  const mine = (snapshot.intents ?? []).find(intent => intent.sessionId === session?.sessionId);
-  if (mine === undefined) return [];
-  return (snapshot.claims ?? [])
-    .filter(claim => claim.ownerSessionId !== session.sessionId
-      && Date.parse(claim.expiresAt) > Date.parse(now)
-      && mine.resourceHints.some(hint => overlaps(hint, claim.resource)))
-    .map(claim => ({ kind: "claim_conflict", priority: ATTENTION_PRIORITY.claim_conflict,
-      sourceId: claim.claimId,
-      summary: `${claim.resource} is claimed by ${claim.ownerSessionId}` }));
-}
-
-/**
- * A resource I hold that a peer has said they intend to touch.
- *
- * The mirror of `claimConflicts`. That one reads my own intent and warns me when
- * what I mean to touch is already claimed. This one reads a peer's intent and
- * warns me, the holder, that someone is heading for what I claimed. Without it
- * intent's only wired reader faced inward: it protected the one declaring intent
- * and told the claim holder nothing, so a claim was a wall nobody was told they
- * were walking into. A claim is advisory - it does not stop the write - so being
- * told early is the whole of the protection it offers.
- *
- * Only my own claims, and never my own intent against them: declaring intent on
- * what you already hold is not someone reaching for it. The peer is named by
- * participant where the roster knows it, because a session id cannot be used
- * with `--to` and an id a reader cannot act on is the trap the projector warns of.
- */
-function claimContended(snapshot, session, now) {
-  if (session === null || session === undefined) return [];
-  const theirs = (snapshot.intents ?? [])
-    .filter(intent => intent.sessionId !== session.sessionId);
-  const nameOf = sessionId => (snapshot.sessions ?? [])
-    .find(item => item.sessionId === sessionId)?.participantId ?? "a peer";
-  return (snapshot.claims ?? [])
-    .filter(claim => claim.ownerSessionId === session.sessionId
-      && Date.parse(claim.expiresAt) > Date.parse(now))
-    .flatMap(claim => {
-      const eyeing = theirs.find(intent =>
-        (intent.resourceHints ?? []).some(hint => overlaps(hint, claim.resource)));
-      return eyeing === undefined ? [] : [{
-        kind: "claim_contended", priority: ATTENTION_PRIORITY.claim_contended,
-        sourceId: claim.claimId,
-        summary: `${claim.resource} - ${nameOf(eyeing.sessionId)} means to work on what you hold` }];
-    });
-}
-
-/**
- * Work waiting on me.
- *
- * Addressed by participant, so a request survives the recipient restarting -
- * the next session of that agent is told about it. A task already taken by one
- * of my sessions matches too, since that session may have been replaced.
- *
- * Unaddressed tasks are deliberately absent. Anyone may take one, but pushing
- * every open task into every turn is how a coordination layer becomes noise.
- */
-function unblockedTasks(snapshot, session, participantId) {
-  const mine = task => (task.assigneeParticipantId !== null
-    && task.assigneeParticipantId === participantId)
-    || (task.assigneeSessionId !== null && task.assigneeSessionId === session?.sessionId);
-  return (snapshot.tasks ?? [])
-    .filter(task => task.state === "pending" && mine(task))
-    .map(task => ({ kind: "task_unblocked", priority: ATTENTION_PRIORITY.task_unblocked,
-      sourceId: task.taskId, summary: task.title }));
-}
-
-/**
- * Work you asked for that nobody is doing any more.
- *
- * A task taken by a session that then crashed stayed `in_progress` for good:
- * the requester was told nothing and nobody else could take it. Unlike the
- * one-shot answers a request produces, this repeats until it is resolved,
- * because it stays true until someone picks the work back up.
- */
-/**
- * A question nobody is left to answer.
- *
- * The task rule below tells a requester when work they asked for is going
- * nowhere. A `requiresAck` message had no such rule, and a message is the other
- * half of the same act: an agent asked a peer a direct question, the peer's
- * session ended without answering, and the asker's next turn was empty. Not
- * "still waiting" - empty. Measured, with the only other agent gone and an
- * unanswered question standing between them.
- *
- * The same kind as the task case, because it is the same fact about the world:
- * you asked, and there is nobody there.
- */
-function unansweredQuestions(snapshot, participantId, onlineParticipants) {
-  const items = [];
-  for (const receipt of snapshot.receipts ?? []) {
-    if (receipt.state === "acknowledged" || receipt.state === "failed") continue;
-    const message = (snapshot.messages ?? [])
-      .find(item => item.messageId === receipt.messageId);
-    if (message === undefined || !message.requiresAck) continue;
-    if (message.fromParticipantId !== participantId) continue;
-    // Not answered yet by someone who is here is ordinary waiting, and saying so
-    // every turn would be noise the reader learns to skip.
-    if (onlineParticipants.has(receipt.recipientParticipantId)) continue;
-    items.push({ kind: "request_stalled", priority: ATTENTION_PRIORITY.request_stalled,
-      sourceId: message.messageId,
-      summary: `${message.subject} - ${receipt.recipientParticipantId} is not here to answer` });
-  }
-  return items;
-}
-
-function stalledRequests(snapshot, participantId, now, pidIsAlive) {
-  // Classified once per session and reused below, for the same reason
-  // collectStatus takes one reading: classifySessionPresence calls pidIsAlive,
-  // a real process.kill(pid, 0) syscall for a session with a recorded pid, so
-  // it is not pure given `now` any more. A second classifying pass here could
-  // disagree with the first - a client exiting between them would leave `live`
-  // saying "online" while a freshly-computed `onlineParticipants` had already
-  // dropped it, inside one attention computation.
-  const live = new Map((snapshot.sessions ?? [])
-    .map(session => [session.sessionId, classifySessionPresence(session, now, pidIsAlive)]));
-  const onlineParticipants = new Set((snapshot.sessions ?? [])
-    .filter(session => live.get(session.sessionId) === "online")
-    .map(session => session.participantId));
-  const goingNowhere = task => {
-    // Taken by someone who has gone quiet.
-    if (task.state === "in_progress") {
-      return task.assigneeSessionId !== null
-        && live.get(task.assigneeSessionId) !== "online";
-    }
-    // Or waiting on an agent that is not here - including one that closed and
-    // never came back, which leaves the work addressed to nobody at all.
-    return task.state === "pending" && task.assigneeParticipantId !== null
-      && !onlineParticipants.has(task.assigneeParticipantId);
-  };
-  return [
-    ...(snapshot.tasks ?? [])
-      .filter(task => task.requestedByParticipantId === participantId
-        && goingNowhere(task))
-      .map(task => ({ kind: "request_stalled", priority: ATTENTION_PRIORITY.request_stalled,
-        sourceId: task.taskId,
-        summary: `${task.title} - nobody is working on it` })),
-    ...unansweredQuestions(snapshot, participantId, onlineParticipants),
-  ];
-}
-
-function coordinatorGaps(snapshot) {
-  return (snapshot.workstreams ?? [])
-    .filter(workstream => workstream.state === "open"
-      && workstream.coordinatorSessionId === null)
-    .map(workstream => ({ kind: "coordinator_missing",
-      priority: ATTENTION_PRIORITY.coordinator_missing,
-      sourceId: workstream.workstreamId, summary: workstream.title }));
-}
-
-export function computeAttention(snapshot, { session, participantId, now, pidIsAlive }) {
-  // Required unconditionally, not only when there happen to be sessions to
-  // classify: `stalledRequests` reaches `classifySessionPresence` only inside a
-  // map/filter over `snapshot.sessions`, so an empty or absent roster let a
-  // missing probe through with nothing to trip over it - the same silent pass
-  // the classifier's own required parameter exists to close, one layer up.
-  if (typeof pidIsAlive !== "function") {
-    throw new AccError(EXIT.USAGE, "computeAttention requires a pidIsAlive probe", {});
+      + "leave it out to start from the beginning", { cursor });
   }
-  return [
-    ...directRequests(snapshot, participantId),
-    ...claimConflicts(snapshot, session, now),
-    ...claimContended(snapshot, session, now),
-    ...expiredClaims(snapshot, session, now),
-    ...unblockedTasks(snapshot, session, participantId),
-    ...coordinatorGaps(snapshot),
-    ...stalledRequests(snapshot, participantId, now, pidIsAlive),
-  ].sort((left, right) => left.priority - right.priority
-    || left.sourceId.localeCompare(right.sourceId));
 }
 
 export function createSyncService(ports, sessions) {
   const { store, clock, pidIsAlive } = ports;
 
-  /**
-   * Any session may request the full Workspace scope. Peer equality is a
-   * knowledge property: no session receives a reduced
-   * view because of its role. The bounded delta is only the ambient default.
-   */
   async function sync(input = {}) {
-    // A cursor that is not a cursor answered "nothing new", every time, for as
-    // long as it was held. `eventsSince` compares sequences as strings, so
-    // `not-a-cursor` sorts after every event there has ever been - and an
-    // adapter holding a corrupt one, or an agent that invented one, saw a quiet
-    // workspace rather than a mistake. `"0000000000000001; DROP"` was quietly
-    // taken as the sequence it starts with.
     if (input.cursor != null) assertCursor(input.cursor);
     assertScope(input.scope);
     const workspaceId = input.workspaceId ?? store.workspaceId;
     const now = clock.now();
     const located = input.sessionId === undefined
-      ? null
-      : await sessions.locateSession(input.sessionId, workspaceId);
+      ? null : await sessions.locateSession(input.sessionId, workspaceId);
     const session = located?.record ?? null;
-
     const durable = await store.snapshot(workspaceId);
-    // A workspace that has not materialised still has a truthful roster: its
-    // sessions live in the ephemeral area. Reading only the durable snapshot
-    // would make a lone session invisible to itself, and would disagree with
-    // what `status` reports from the same state.
     const snapshot = durable.workspace !== null
       ? durable
       : { ...durable,
@@ -293,7 +43,6 @@ export function createSyncService(ports, sessions) {
       input.limit ?? DEFAULT_LIMIT);
     const attention = computeAttention(snapshot, { session,
       participantId: session?.participantId ?? input.participantId, now, pidIsAlive });
-
     const roster = snapshot.sessions.map(item => ({
       sessionId: item.sessionId,
       participantId: item.participantId,
@@ -302,14 +51,10 @@ export function createSyncService(ports, sessions) {
       branch: item.branch ?? null,
       presence: classifySessionPresence(item, now, pidIsAlive),
     }));
-
-    // Solo zero-overhead: one live session, no claims and
-    // no attention means an empty result, not a "nothing to report" banner.
     const peers = roster.filter(item => item.sessionId !== session?.sessionId
       && item.presence !== "offline");
     const solo = peers.length === 0 && attention.length === 0
       && snapshot.claims.length === 0;
-
     return {
       cursor: page.cursor,
       scope: input.scope === "full" ? "full" : "delta",

package/node_modules/@agents-can-communicate/delivery-router/package.json

@@ -0,0 +1,12 @@
+{
+  "name": "@agents-can-communicate/delivery-router",
+  "version": "0.2.0",
+  "private": true,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.mjs"
+  },
+  "files": [
+    "src/"
+  ]
+}

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

@@ -0,0 +1 @@
+export { createDeliveryRouter } from "./router.mjs";