agents-can-communicate 0.1.18 → 0.2.0

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,
       },
     };

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,299 +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,
-  unread_note: 8,
-});
-
-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 note that was delivered once and then left unanswered.
- *
- * A `note` carries no acknowledgement obligation, so unlike a `requiresAck`
- * message it raises no direct_request and, once injected, drops out of the
- * inbox for good. Agents put decisions in notes anyway, and one delivered that
- * way was missed for three hours because nothing stood behind it. This is the
- * single low-priority breadcrumb that keeps a delivered-but-unacknowledged note
- * recoverable: it fires only while the receipt reads `injected`, so the runner
- * advancing it to `seen` after one showing makes it one-shot rather than a
- * standing nag - the very noise a reader learns to skip. A `queued` note is
- * about to be shown in full this turn and needs no breadcrumb yet.
- *
- * Only the recipient's, and named by message id so `acc inbox --message` or
- * `acc ack --message` can act on it without a workspace-wide lookup.
- */
-function unreadNotes(snapshot, participantId) {
-  const items = [];
-  for (const receipt of snapshot.receipts ?? []) {
-    if (receipt.recipientParticipantId !== participantId) continue;
-    if (receipt.state !== "injected") continue;
-    const message = (snapshot.messages ?? [])
-      .find(item => item.messageId === receipt.messageId);
-    // A requiresAck message already carries a standing direct_request; a second
-    // line here would be two reminders for one obligation.
-    if (message === undefined || message.requiresAck) continue;
-    items.push({ kind: "unread_note", priority: ATTENTION_PRIORITY.unread_note,
-      sourceId: message.messageId,
-      summary: `a note you have not acknowledged - \`acc inbox --message `
-        + `${message.messageId}\` to read it` });
+      + "leave it out to start from the beginning", { cursor });
   }
-  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", {});
-  }
-  return [
-    ...directRequests(snapshot, participantId),
-    ...unreadNotes(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,
@@ -329,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,
@@ -338,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";

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

@@ -0,0 +1,117 @@
+import { effectiveCapabilities } from "@agents-can-communicate/adapter-sdk";
+
+const PLATFORM = `${process.platform}-${process.arch}`;
+const SAFE_ERRORS = new Set(["ambiguous_recipient_sessions", "delivery_disabled",
+  "recipient_busy", "recipient_unavailable", "transport_error", "transport_rejected",
+  "unsupported_client_version"]);
+const NAMED_LIVE_TRANSPORTS = new Set(["claude-channel", "codex-app-server"]);
+
+const adaptersById = adapters => adapters instanceof Map
+  ? adapters
+  : new Map((Array.isArray(adapters) ? adapters : Object.values(adapters ?? {}))
+    .map(adapter => [adapter.id, adapter]));
+
+const permits = (policy, kind) => policy === "all"
+  || (policy === "actionable" && ["question", "request", "handoff"].includes(kind));
+
+const durable = (recipientParticipantId, errorCode) => ({ recipientParticipantId,
+  outcome: "queued", transport: "durable", errorCode });
+
+const settled = receipt => ({ recipientParticipantId: receipt.recipientParticipantId,
+  outcome: receipt.state, transport: "durable" });
+
+function safeTransport(value, opaqueEndpointRef) {
+  if (NAMED_LIVE_TRANSPORTS.has(value) && value !== opaqueEndpointRef) return value;
+  // Both markers are fixed router vocabulary. The alternate prevents even a
+  // coincidental endpoint value equal to the primary redaction from escaping.
+  return opaqueEndpointRef === "live-adapter" ? "native-live" : "live-adapter";
+}
+
+export function createDeliveryRouter({ service, adapters, clock }) {
+  const registry = adaptersById(adapters);
+
+  async function recordFailure(binding, message, participantId, transport, safeErrorCode) {
+    await service.recordOfferFailed({ messageId: message.messageId,
+      recipientParticipantId: participantId, targetSessionId: binding.sessionId,
+      targetGeneration: binding.generation,
+      transport: safeTransport(transport, binding.opaqueEndpointRef), adapterId: binding.adapterId,
+      clientVersion: binding.clientVersion, safeErrorCode }).catch(() => null);
+  }
+
+  async function offerTo(message, participantId, now) {
+    const receipt = await service.readReceipt({ messageId: message.messageId,
+      recipientParticipantId: participantId });
+    if (receipt.state !== "queued") return settled(receipt);
+    const liveSessions = await service.listLiveSessions({ participantId, now });
+    if (liveSessions.length === 0) return durable(participantId, "recipient_unavailable");
+    if (liveSessions.length > 1) {
+      return durable(participantId, "ambiguous_recipient_sessions");
+    }
+    const [target] = liveSessions;
+    const bindings = (await service.listDeliveryBindings({ participantId, now }))
+      .filter(binding => binding.sessionId === target.sessionId
+        && binding.generation === target.generation);
+    if (bindings.length === 0) return durable(participantId, "recipient_unavailable");
+    const permitted = bindings.filter(binding => binding.livePolicy !== "off"
+      && permits(binding.livePolicy, message.kind));
+    if (permitted.length === 0) return durable(participantId, "delivery_disabled");
+    const reachable = permitted.filter(binding => binding.availableModes.includes("livePush"));
+    if (reachable.length === 0) return durable(participantId, "recipient_unavailable");
+    const certified = reachable.map(binding => ({ binding,
+      adapter: registry.get(binding.adapterId) }))
+      .filter(({ binding, adapter }) => adapter !== undefined
+        && effectiveCapabilities(adapter,
+          { clientVersion: binding.clientVersion, platform: PLATFORM }).delivery.livePush);
+    if (certified.length === 0) {
+      return durable(participantId, "unsupported_client_version");
+    }
+    if (certified.length > 1) {
+      return durable(participantId, "ambiguous_recipient_sessions");
+    }
+
+    const { binding, adapter } = certified[0];
+    let response;
+    try {
+      response = await adapter.offerMessage({ binding, message });
+    } catch {
+      await recordFailure(binding, message, participantId, "live-adapter", "transport_error");
+      return durable(participantId, "transport_error");
+    }
+    const transport = safeTransport(response?.transport, binding.opaqueEndpointRef);
+    if (response?.accepted !== true) {
+      const code = SAFE_ERRORS.has(response?.safeErrorCode)
+        ? response.safeErrorCode : "transport_rejected";
+      await recordFailure(binding, message, participantId, transport, code);
+      return durable(participantId, code);
+    }
+    if (response.clientVersion !== binding.clientVersion) {
+      await recordFailure(binding, message, participantId, transport,
+        "unsupported_client_version");
+      return durable(participantId, "unsupported_client_version");
+    }
+    try {
+      await service.recordOfferSucceeded({ messageId: message.messageId,
+        recipientParticipantId: participantId, targetSessionId: binding.sessionId,
+        targetGeneration: binding.generation, transport, adapterId: binding.adapterId,
+        clientVersion: binding.clientVersion });
+    } catch {
+      await recordFailure(binding, message, participantId, transport, "transport_error");
+      return durable(participantId, "transport_error");
+    }
+    return { recipientParticipantId: participantId, outcome: "offered", transport };
+  }
+
+  async function offer(message) {
+    if (!Array.isArray(message?.toParticipantIds) || message.toParticipantIds.length === 0) {
+      return [];
+    }
+    const now = clock.now();
+    const outcomes = [];
+    for (const participantId of message.toParticipantIds) {
+      outcomes.push(await offerTo(message, participantId, now));
+    }
+    return outcomes;
+  }
+
+  return Object.freeze({ offer });
+}

package/node_modules/@agents-can-communicate/hook-runner/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/hook-runner",
-  "version": "0.1.18",
+  "version": "0.2.0",
   "private": true,
   "type": "module",
   "exports": {

package/node_modules/@agents-can-communicate/hook-runner/src/client-version.mjs

@@ -0,0 +1,20 @@
+import { execFile } from "node:child_process";
+
+const VERSION = /(?:^|[^0-9A-Za-z])v?(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)(?:\b|$)/;
+
+export function parseClientVersion(output) {
+  return typeof output === "string" ? VERSION.exec(output)?.[1] ?? null : null;
+}
+
+/** Probe the client binary once when its real session starts. */
+export function probeClientVersion(adapter, { timeoutMs = 1_000 } = {}) {
+  return new Promise(resolve => {
+    execFile(adapter.client.command, adapter.client.versionArgs ?? ["--version"], {
+      timeout: timeoutMs,
+      windowsHide: true,
+    }, (error, stdout, stderr) => {
+      if (error !== null) return resolve(null);
+      resolve(parseClientVersion(`${stdout}${stderr}`));
+    });
+  });
+}