agents-can-communicate 0.8.0 → 0.8.1

package/node_modules/@agents-can-communicate/adapter-sdk/src/native-delivery.mjs

@@ -1,17 +1,22 @@
 import { CONTRACT_ID, FINGERPRINT, HANDSHAKE_KEYS, KNOWN_BAD_REASON, NATIVE_BINDING_MODES,
-  NATIVE_PLATFORMS, PLANNABLE_ACTIVATION_KINDS, PROBE_KEYS, TIMESTAMP, assertModes,
-  assertReasonCode, closed, compareStableVersions, deepFreeze, isPlainObject, isText,
-  parseStableVersion, usage } from "./native-vocabulary.mjs";
+  PLANNABLE_ACTIVATION_KINDS, PROBE_KEYS, TIMESTAMP, assertModes, assertReasonCode, closed,
+  compareStableVersions, deepFreeze, isPlainObject, isText, parseStableVersion, usage }
+  from "./native-vocabulary.mjs";
+import { compareVersionOrder, versionOrder } from "./certification.mjs";
 
-// The native-delivery compatibility contract: a per-platform minimum that is a
-// real passing capture, one or more anchors naming the captured protocol, an
-// explicit denylist, and the activation kinds an adapter may ask the installer
-// for. There is deliberately no maximum: a newer stable client is admitted only
+// The native-delivery compatibility contract: a minimum that is a real passing
+// capture, one or more anchors naming the captured protocol, an explicit
+// denylist, and the activation kinds an adapter may ask the installer for.
+// There is deliberately no maximum: a newer stable client is admitted only
 // when a current read-only probe and a per-session handshake confirm the same
-// protocol contract. Exact-version certification still governs every other
-// capability; this rule is used for native live delivery alone.
+// protocol contract. There is no platform either: a capture records where a
+// behaviour was observed, the minimum it establishes applies everywhere, and
+// the probe and handshake decide on the machine in hand (see
+// docs/design/2026-09-26-native-delivery-across-platforms.md). Certification
+// evidence still governs every other capability; this rule is used for native
+// live delivery alone.
 
-export { NATIVE_ACTIVATION_KINDS, NATIVE_BINDING_MODES, NATIVE_PLATFORMS, NATIVE_REASON_CODES,
+export { NATIVE_ACTIVATION_KINDS, NATIVE_BINDING_MODES, NATIVE_REASON_CODES,
   PLANNABLE_ACTIVATION_KINDS, compareStableVersions, parseStableVersion } from "./native-vocabulary.mjs";
 export { validateNativeActivationPlan } from "./native-activation.mjs";
 
@@ -29,8 +34,16 @@ export function validateNativeDeliveryContract(value, { certification, client })
   // the next-turn hook, which records the offer itself once its stdout carried
   // the body. Recording a wake as offered would hide the body from that hook.
   const offerKind = Object.hasOwn(value ?? {}, "offerKind") ? value.offerKind : "message";
+  // The per-platform shape 0.8.0 and earlier declared. Refused by name: an
+  // adapter built against that SDK should learn what replaced it, not fail on
+  // a generic unknown field.
+  if (Object.hasOwn(value ?? {}, "minimumByPlatform")) {
+    usage("nativeDelivery.minimumByPlatform is no longer declared; a capture's minimum applies on "
+      + "every platform, so declare nativeDelivery.minimum instead "
+      + "(docs/design/2026-09-26-native-delivery-across-platforms.md)");
+  }
   closed({ ...value, policySource, offerKind },
-    ["minimumByPlatform", "anchors", "knownBad", "activationKinds", "policySource", "offerKind"],
+    ["minimum", "anchors", "knownBad", "activationKinds", "policySource", "offerKind"],
     "nativeDelivery");
   if (policySource !== "installation-record") {
     usage("nativeDelivery.policySource must be installation-record");
@@ -38,48 +51,43 @@ export function validateNativeDeliveryContract(value, { certification, client })
   if (!["message", "wake"].includes(offerKind)) {
     usage("nativeDelivery.offerKind must be message or wake");
   }
-  const minimums = value.minimumByPlatform;
-  if (!isPlainObject(minimums) || Object.keys(minimums).length === 0) {
-    usage("nativeDelivery.minimumByPlatform must map at least one captured platform to a version");
-  }
-  for (const [platform, version] of Object.entries(minimums)) {
-    if (!NATIVE_PLATFORMS.includes(platform)) {
-      usage(`nativeDelivery.minimumByPlatform names an unknown platform ${platform}`);
-    }
-    if (parseStableVersion(version) === null) {
-      usage(`nativeDelivery.minimumByPlatform ${platform} must be a stable version`);
-    }
+  const minimum = value.minimum;
+  if (parseStableVersion(minimum) === null) {
+    usage("nativeDelivery.minimum must be a stable version");
   }
   if (!Array.isArray(value.anchors) || value.anchors.length === 0) {
     usage("nativeDelivery.anchors must name at least one passing capture");
   }
   const anchors = value.anchors.map((anchor, index) => {
-    closed(anchor, ["platform", "version", "protocolContract"], "nativeDelivery anchor");
-    const minimum = minimums[anchor.platform];
-    if (minimum === undefined) {
-      usage(`nativeDelivery anchor ${index} platform ${anchor.platform} has no minimum`);
+    if (Object.hasOwn(anchor ?? {}, "platform")) {
+      usage(`nativeDelivery anchor ${index} names a platform; the platform a capture was taken on `
+        + "is recorded by its evidence, and the anchor names the version alone "
+        + "(docs/design/2026-09-26-native-delivery-across-platforms.md)");
+    }
+    closed(anchor, ["version", "protocolContract"], "nativeDelivery anchor");
+    if (parseStableVersion(anchor.version) === null) {
+      usage(`nativeDelivery anchor ${index} version must be a stable version`);
     }
-    if (parseStableVersion(anchor.version) === null
-      || compareStableVersions(anchor.version, minimum) < 0) {
-      usage(`nativeDelivery anchor ${index} version must be a stable version at or above the minimum`);
+    if (compareStableVersions(anchor.version, minimum) < 0) {
+      usage(`nativeDelivery anchor ${index} version ${anchor.version} is below the minimum ${minimum}: `
+        + "the minimum must be the first passing capture");
     }
     if (!isText(anchor.protocolContract) || !CONTRACT_ID.test(anchor.protocolContract)) {
       usage(`nativeDelivery anchor ${index} protocolContract must be a closed identifier`);
     }
+    // Where the capture was taken is provenance the evidence row keeps; the
+    // anchor is proven by a passing capture of this version on any platform.
     const proven = (certification?.evidence ?? []).some(item => item.result === "pass"
       && item.capability === "delivery.livePush" && item.client === client
-      && item.version === anchor.version && item.platform === anchor.platform);
+      && item.version === anchor.version);
     if (!proven) {
-      usage(`nativeDelivery anchor ${anchor.version} on ${anchor.platform} has no passing `
-        + "delivery.livePush certification", { anchor });
+      usage(`nativeDelivery anchor ${anchor.version} has no passing delivery.livePush certification`,
+        { anchor });
     }
     return { ...anchor };
   });
-  for (const [platform, minimum] of Object.entries(minimums)) {
-    if (!anchors.some(anchor => anchor.platform === platform && anchor.version === minimum)) {
-      usage(`nativeDelivery minimum ${minimum} on ${platform} must be the first passing capture: `
-        + "no anchor matches it");
-    }
+  if (!anchors.some(anchor => compareStableVersions(anchor.version, minimum) === 0)) {
+    usage(`nativeDelivery minimum ${minimum} must be the first passing capture: no anchor matches it`);
   }
   if (!Array.isArray(value.knownBad)) usage("nativeDelivery.knownBad must be an array");
   const knownBad = value.knownBad.map(entry => {
@@ -104,24 +112,29 @@ export function validateNativeDeliveryContract(value, { certification, client })
     || kinds.some(kind => !PLANNABLE_ACTIVATION_KINDS.includes(kind))) {
     usage(`nativeDelivery.activationKinds must be unique entries of ${PLANNABLE_ACTIVATION_KINDS.join(", ")}`);
   }
-  return deepFreeze({ minimumByPlatform: { ...minimums }, anchors, knownBad,
-    activationKinds: [...kinds], policySource, offerKind });
+  return deepFreeze({ minimum, anchors, knownBad, activationKinds: [...kinds], policySource,
+    offerKind });
 }
 
-function knownBadHit(contract, version) {
+// `order` is the client's release triple; the denylist names stable versions,
+// so a prerelease of a denylisted release is on it too.
+function knownBadHit(contract, order) {
+  const hit = (left, right) => compareVersionOrder(left, versionOrder(right));
   return contract.knownBad.some(entry => (Object.hasOwn(entry, "version")
-    ? compareStableVersions(version, entry.version) === 0
-    : compareStableVersions(version, entry.from) >= 0 && compareStableVersions(version, entry.to) <= 0));
+    ? hit(order, entry.version) === 0
+    : hit(order, entry.from) >= 0 && hit(order, entry.to) <= 0));
 }
 
 // Judges one reported client version against an adapter's captured
-// native-delivery contract: is the platform captured, is the version at or
-// above the captured minimum, and is it not on the denylist. Returns
+// native-delivery contract: is the version at or above the captured minimum,
+// and is it not on the denylist. Returns
 // { reasonCode, minimumVersion, protocolContract }; reasonCode is null when
 // the version satisfies the contract, otherwise one of
-// "native_delivery_unsupported", "platform_not_captured",
-// "version_unavailable", "prerelease_not_captured", "below_minimum_version",
-// or "known_bad_version".
+// "native_delivery_unsupported", "version_unavailable", "below_minimum_version",
+// or "known_bad_version". The platform the caller runs on plays no part: the
+// minimum was captured somewhere and applies everywhere. A prerelease is
+// judged by its release triple, as hook capabilities are: what admits it is
+// the protocol contract the probe or handshake reports, not the suffix.
 //
 // This is the static half of the rule only: it never contacts the client, so
 // passing here proves nothing about whether a live probe or handshake
@@ -130,38 +143,33 @@ function knownBadHit(contract, version) {
 // validateNativeHandshake below, and the delivery router's own offer check,
 // which uses this function alone because a response already carries no probe
 // or handshake shape to check further).
-export function evaluateVersionContract(adapter, { clientVersion, platform }) {
+export function evaluateVersionContract(adapter, { clientVersion } = {}) {
   const contract = adapter?.nativeDelivery;
-  // `== null` rather than `=== undefined`: a null declaration is as much "no
-  // contract" as a missing one, and reading `contract.minimumByPlatform` off it
-  // threw the very TypeError the guard below exists to prevent. defineAdapter
-  // cannot produce that shape; a hand-built registry entry can.
-  if (contract == null) {
-    return { reasonCode: "native_delivery_unsupported", minimumVersion: null, protocolContract: null };
-  }
-  const uncaptured = { reasonCode: "platform_not_captured", minimumVersion: null,
+  const unsupported = { reasonCode: "native_delivery_unsupported", minimumVersion: null,
     protocolContract: null };
-  // validateNativeDeliveryContract guarantees a minimum map and a matching
-  // anchor, but this function is also handed adapter objects that never went
-  // through it. A declaration missing either half has captured nothing for
-  // this platform, which is a closed answer - not a TypeError raised deep
-  // inside a delivery offer, far from the declaration that caused it. Every
-  // other entry point below already answers malformed input this way.
-  if (typeof platform !== "string" || !isPlainObject(contract.minimumByPlatform)) return uncaptured;
-  const minimumVersion = contract.minimumByPlatform[platform] ?? null;
-  if (minimumVersion === null) return uncaptured;
+  // `== null` rather than `=== undefined`: a null declaration is as much "no
+  // contract" as a missing one, and reading `contract.minimum` off it threw
+  // the very TypeError the guard below exists to prevent. defineAdapter cannot
+  // produce that shape; a hand-built registry entry can.
+  if (contract == null) return unsupported;
+  // validateNativeDeliveryContract guarantees a minimum and a matching anchor,
+  // but this function is also handed adapter objects that never went through
+  // it. A declaration missing either half has captured nothing, which is a
+  // closed answer - not a TypeError raised deep inside a delivery offer, far
+  // from the declaration that caused it. Every other entry point below
+  // already answers malformed input this way.
+  const minimumVersion = isText(contract.minimum) ? contract.minimum : null;
+  if (minimumVersion === null) return unsupported;
   const anchor = (Array.isArray(contract.anchors) ? contract.anchors : [])
-    .find(item => item.platform === platform && item.version === minimumVersion);
-  if (anchor === undefined) return uncaptured;
+    .find(item => item?.version === minimumVersion);
+  if (anchor === undefined) return unsupported;
   const facts = { minimumVersion, protocolContract: anchor.protocolContract };
-  if (!isText(clientVersion)) return { ...facts, reasonCode: "version_unavailable" };
-  if (parseStableVersion(clientVersion) === null) {
-    return { ...facts, reasonCode: "prerelease_not_captured" };
-  }
-  if (compareStableVersions(clientVersion, minimumVersion) < 0) {
+  const order = versionOrder(clientVersion);
+  if (order === null) return { ...facts, reasonCode: "version_unavailable" };
+  if (compareVersionOrder(order, versionOrder(minimumVersion)) < 0) {
     return { ...facts, reasonCode: "below_minimum_version" };
   }
-  if (knownBadHit(contract, clientVersion)) return { ...facts, reasonCode: "known_bad_version" };
+  if (knownBadHit(contract, order)) return { ...facts, reasonCode: "known_bad_version" };
   return { ...facts, reasonCode: null };
 }
 
@@ -184,13 +192,13 @@ function validateNativeProbe(probe) {
   return probe;
 }
 
-export function evaluateNativeEligibility(adapter, { clientVersion, platform, probe }) {
+export function evaluateNativeEligibility(adapter, { clientVersion, probe }) {
   // The probe names the process that will serve the delivery. Judging the
   // detected binary instead refuses a service that satisfies the contract.
   // Only the version is read here; the shape is validated where it always was,
   // so a malformed probe still returns a closed result rather than throwing.
   const serving = isText(probe?.clientVersion) ? probe.clientVersion : clientVersion;
-  const rule = evaluateVersionContract(adapter, { clientVersion: serving, platform });
+  const rule = evaluateVersionContract(adapter, { clientVersion: serving });
   const base = { eligible: false, reasonCode: null, minimumVersion: rule.minimumVersion,
     protocolContract: rule.protocolContract, modes: [] };
   const closedResult = reasonCode => deepFreeze({ ...base, reasonCode });
@@ -242,13 +250,13 @@ function validateNativeHandshakeShape(handshake) {
 // the two records disagreed on every machine where a daemon had updated under
 // its CLI, which is exactly the case the release exists to support. A refused
 // verdict admits nothing and carries null.
-export function validateNativeHandshake(adapter, { clientVersion, platform, handshake }) {
+export function validateNativeHandshake(adapter, { clientVersion, handshake }) {
   // Same rationale as the probe: the handshake names the session that will
   // actually serve, so the static rule is judged against that version. Only
   // the version is read here; the shape is validated where it always was, so
   // a malformed handshake still returns a closed result rather than throwing.
   const serving = isText(handshake?.clientVersion) ? handshake.clientVersion : clientVersion;
-  const rule = evaluateVersionContract(adapter, { clientVersion: serving, platform });
+  const rule = evaluateVersionContract(adapter, { clientVersion: serving });
   const base = { ok: false, reasonCode: null, clientVersion: null,
     protocolContract: rule.protocolContract, modes: [],
     opaqueEndpointRef: null, leaseUntil: null };

package/node_modules/@agents-can-communicate/adapter-sdk/src/native-vocabulary.mjs

@@ -18,12 +18,12 @@ export const NATIVE_ACTIVATION_KINDS = Object.freeze([
 // The kinds an adapter may still ask for.
 export const PLANNABLE_ACTIVATION_KINDS = Object.freeze(["native-config", "native-service"]);
 
-export const NATIVE_PLATFORMS = Object.freeze([
-  "darwin-arm64", "darwin-x64", "linux-arm64", "linux-x64", "win32-x64",
-]);
-
 // Every reason a client is not live, closed so doctor, hooks, and docs share
 // one vocabulary and vendor strings never leak through it.
+// "platform_not_captured" and "prerelease_not_captured" are historical: 0.8.0
+// and earlier refused a platform no capture named and any prerelease suffix,
+// and their native-attempt records carry both. Nothing produces either any
+// more (docs/design/2026-09-26-native-delivery-across-platforms.md).
 export const NATIVE_REASON_CODES = Object.freeze([
   "native_delivery_unsupported", "platform_not_captured", "version_unavailable",
   "prerelease_not_captured", "below_minimum_version", "known_bad_version",

package/node_modules/@agents-can-communicate/cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/cli",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "private": true,
   "type": "module",
   "exports": {

package/node_modules/@agents-can-communicate/cli/src/main.mjs

@@ -200,12 +200,11 @@ export function describeStatus(status) {
   const offered = status.counts.unretrieved?.offered ?? 0;
   const withOffers = offered === 0 ? line : `${line}; ${offered} offered, not retrieved`;
   // Status lists a participant with no open session only while messages wait
-  // for it; each is named here, with the client's reason when it gave one.
-  const waiting = (status.participants ?? []).filter(item => item.presence === "offline")
-    .map(item => {
-      const count = (item.unretrieved?.queued ?? 0) + (item.unretrieved?.offered ?? 0);
-      return `${item.participantId} (${item.endReason === "clear" ? "cleared, " : ""}${count})`;
-    });
+  // for it; each is named here, with the client's reason when it gave one. The
+  // count is what its next turn would still show, never an offer already made.
+  const waiting = (status.participants ?? [])
+    .filter(item => item.presence === "offline" && (item.waiting ?? 0) > 0)
+    .map(item => `${item.participantId} (${item.endReason === "clear" ? "cleared, " : ""}${item.waiting})`);
   return waiting.length === 0 ? withOffers
     : `${withOffers}; waiting for a closed session: ${waiting.join(", ")}`;
 }

package/node_modules/@agents-can-communicate/cli/src/managed-runtime/maintenance.mjs

@@ -31,24 +31,18 @@ export function maintenanceContext(control, env) {
  * untouched, so a genuinely stale or unbound service is still selected.
  *
  * The contract answers two different questions with one field, and reading
- * every non-null code as a refusal conflated them. "platform_not_captured" and
- * "native_delivery_unsupported" are not verdicts on any version: the first is
- * a complete, valid declaration that records nothing for the platform this
- * process runs on, and the second is an adapter that declares no native
- * delivery at all. Every shipped adapter captures darwin-arm64 alone, so on
- * Linux and on an Intel Mac the first of those is the ordinary answer - and it
- * made every ready daemon a restart candidate, including one already serving
- * exactly the version its CLI is running. That is the complaint this work
- * began from, reproduced on every machine but one. With no opinion to act on,
- * the decision falls back to the comparison that governed before this branch:
- * the served version against the CLI's. */
-const UNCAPTURED = new Set(["platform_not_captured", "native_delivery_unsupported"]);
+ * every non-null code as a refusal conflated them. "native_delivery_unsupported"
+ * is not a verdict on any version: it is an adapter that declares no native
+ * delivery at all. With no opinion to act on, the decision falls back to the
+ * comparison that governed before the contract existed: the served version
+ * against the CLI's. A contract captured on one platform judges the daemon on
+ * every platform, so the host this process runs on is not asked. */
+const NO_CONTRACT = "native_delivery_unsupported";
 
 const servingVersionIsContrary = (adapter, snapshot) => {
-  const { reasonCode } = evaluateVersionContract(adapter,
-    { clientVersion: snapshot.serverVersion, platform: HOST_PLATFORM });
+  const { reasonCode } = evaluateVersionContract(adapter, { clientVersion: snapshot.serverVersion });
   if (reasonCode === null) return false;
-  if (!UNCAPTURED.has(reasonCode)) return true;
+  if (reasonCode !== NO_CONTRACT) return true;
   return snapshot.serverVersion !== snapshot.cliVersion;
 };
 

package/node_modules/@agents-can-communicate/cli/src/managed-runtime/pins.mjs

@@ -9,6 +9,7 @@ import { canonicalManagerRoot, managedDirectory, readManagedJson, syncDirectory,
   writeManagedJson } from "./state.mjs";
 
 const SCHEMA_VERSION = 1;
+const isPid = value => Number.isSafeInteger(value) && value > 0;
 
 // Same hashing rule as session bindings: a foreign harness id never selects
 // which file is written.
@@ -30,13 +31,19 @@ export const hookEntrypointFor = root => path.join(root, "bin", "entrypoints", "
 // once, on every entry point - matching every other managed-runtime module -
 // is what makes "the root the writer used" and "the root the reader used"
 // the same derivation instead of two that merely happen to agree today.
+//
+// A pin holds its generation until its client is confirmed dead, so a pin with
+// no client pid could never be released and kept its generation forever. A
+// session whose client cannot be found goes unpinned instead, and its hooks run
+// the active generation - the fallback every unresolvable pin already gets.
 export async function writePin({ root, harnessSessionId, runtimeRoot, version, storeVersion,
   clientPid }) {
+  if (!isPid(clientPid)) return;
   root = await canonicalManagerRoot(root);
   await managedDirectory(path.join(root, "pins"), { create: true });
   await writeManagedJson(fileFor(root, harnessSessionId), { schemaVersion: SCHEMA_VERSION,
     harnessSessionId, runtimeRoot, version, storeVersion: storeVersion ?? null,
-    clientPid: clientPid ?? null, createdAt: new Date().toISOString() });
+    clientPid, createdAt: new Date().toISOString() });
 }
 
 export async function readPin({ root, harnessSessionId }) {
@@ -105,7 +112,9 @@ export async function resolvePinnedGeneration({ root, harnessSessionId, active }
 }
 
 /** A client that exits without SessionEnd leaves its pin behind. Admission
- * already reaps dead leases; pins follow the same confirmed-death rule. */
+ * already reaps dead leases; pins follow the same confirmed-death rule. A pin
+ * that names no client, which 0.8.0 and earlier wrote when the pid was not yet
+ * known, is reaped outright: nothing could ever prove its session over. */
 export async function reapPins({ root, pidIsAlive = defaultPidIsAlive } = {}) {
   root = await canonicalManagerRoot(root);
   const directory = path.join(root, "pins");
@@ -115,8 +124,8 @@ export async function reapPins({ root, pidIsAlive = defaultPidIsAlive } = {}) {
     if (!name.endsWith(".json")) continue;
     const file = path.join(directory, name);
     const record = await readManagedJson(file).catch(() => null);
-    const pid = Number.isSafeInteger(record?.clientPid) ? record.clientPid : null;
-    if (pid !== null && await confirmedDead(pid, pidIsAlive)) {
+    if (record?.schemaVersion !== SCHEMA_VERSION) continue; // Unknown shape: an unknown holder.
+    if (!isPid(record.clientPid) || await confirmedDead(record.clientPid, pidIsAlive)) {
       await rm(file, { force: true });
       removed = true;
     }

package/node_modules/@agents-can-communicate/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/core",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -34,11 +34,26 @@ export function offerFacts(receipt) {
 export function dueForRepeat(message, receipt, now) {
   const offer = offerFacts(receipt);
   return message != null && message.toParticipantIds.length > 0
-    && receipt?.state === "offered" && offer !== null
-    && offer.transport !== "next-turn" && offer.repeatedAt === null
+    && receipt?.state === "offered" && offer !== null && liveAndUnrepeated(offer)
     && Date.parse(now) - Date.parse(offer.at) >= REPEAT_OFFER_AFTER_MS;
 }
 
+// A live transport took the bytes, and the next turn has not shown them again.
+const liveAndUnrepeated = offer => offer.transport !== "next-turn" && offer.repeatedAt === null;
+
+/**
+ * Whether the recipient's next turn could still show this receipt's message:
+ * queued, or offered live and not yet shown again. A next-turn offer already
+ * put the body in the recipient's context. An offer an older ACC recorded
+ * without facts is unknown, so it counts as still to be shown.
+ */
+export function awaitsNextTurn(receipt) {
+  if (receipt?.state === "queued") return true;
+  if (receipt?.state !== "offered") return false;
+  const offer = offerFacts(receipt);
+  return offer === null || liveAndUnrepeated(offer);
+}
+
 export const SAFE_OFFER_ERROR_CODES = Object.freeze([
   "ambiguous_recipient_sessions",
   "delivery_disabled",

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

@@ -2,6 +2,7 @@ import { classifySessionPresence } from "./sessions.mjs";
 import { computeAttention } from "./attention.mjs";
 import { isCurrentIntent } from "./intents.mjs";
 import { decisionView, isCurrentDecision } from "./decision-state.mjs";
+import { awaitsNextTurn } from "./receipts.mjs";
 
 /**
  * Protection level, reported from what is actually enforceable.
@@ -96,6 +97,10 @@ export function createStatusService(ports, sessions, deliveryBindings) {
       .filter(isCurrentDecision).map(message => message.messageId));
     const unretrieved = new Map();
     const tally = key => unretrieved.get(key) ?? { queued: 0, offered: 0 };
+    // Narrower than unretrieved: what the recipient's next turn would still
+    // show. An offer the next turn already made is unretrieved, but nothing
+    // will ever reach the recipient for it again.
+    const waiting = new Map();
     for (const receipt of snapshot.receipts) {
       if (!current.has(receipt.messageId)
         || !["queued", "offered"].includes(receipt.state)) continue;
@@ -103,6 +108,10 @@ export function createStatusService(ports, sessions, deliveryBindings) {
         const counts = tally(key);
         unretrieved.set(key, { ...counts, [receipt.state]: counts[receipt.state] + 1 });
       }
+      if (awaitsNextTurn(receipt)) {
+        waiting.set(receipt.recipientParticipantId,
+          (waiting.get(receipt.recipientParticipantId) ?? 0) + 1);
+      }
     }
 
     // A participant with no live session but messages waiting for it stays in
@@ -116,7 +125,7 @@ export function createStatusService(ports, sessions, deliveryBindings) {
       }
     }
     const awaited = new Set([...latest.values()].filter(session => !liveParticipants.has(session.participantId)
-      && (tally(session.participantId).queued + tally(session.participantId).offered) > 0)
+      && (waiting.get(session.participantId) ?? 0) > 0)
       .map(session => session.sessionId));
 
     return {
@@ -149,7 +158,10 @@ export function createStatusService(ports, sessions, deliveryBindings) {
         unretrieved: tally(session.participantId),
         // The client's reason when it ended the session, such as Claude Code's
         // "clear". Kept in the record's extensions, so it is null for 0.7.x.
-        ...(presence === "offline" ? { endReason: session.extensions?.endReason ?? null } : {}),
+        // And how many messages its next turn would still show, the count that
+        // keeps it listed.
+        ...(presence === "offline" ? { endReason: session.extensions?.endReason ?? null,
+          waiting: waiting.get(session.participantId) ?? 0 } : {}),
       })),
       // 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

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/delivery-router",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -14,14 +14,14 @@ function sameBinding(current, expected, leaseUntil) {
 }
 
 export async function refreshExpiredBinding({ service, adapter, binding, runtimeDir,
-  platform, clock, timeoutMs = 750 }) {
+  clock, timeoutMs = 750 }) {
   if (typeof adapter?.refreshNativeSession !== "function") return false;
   const now = Date.parse(clock.now());
   if (!Number.isFinite(now)) return false;
   try {
     const handshake = await adapter.refreshNativeSession({ binding, runtimeDir, timeoutMs });
     const validated = validateNativeHandshake(adapter, {
-      clientVersion: binding.clientVersion, platform, handshake,
+      clientVersion: binding.clientVersion, handshake,
     });
     if (!validated.ok || validated.opaqueEndpointRef !== binding.opaqueEndpointRef) return false;
     const requestedLease = Date.parse(validated.leaseUntil);

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

@@ -21,35 +21,12 @@ const LIVE_POLICIES = new Set(["off", "actionable", "all"]);
 const permits = (policy, kind) => policy === "all"
   || (policy === "actionable" && ACTIONABLE.has(kind));
 
-// A native-delivery contract is captured per platform, and the only platform a
-// router can judge an offer against is the one it is running on - which is why
-// both entrypoints pass exactly this value. Leaving the parameter optional made
-// its absence silently disable every live offer: `undefined` reached the
-// contract check as "platform_not_captured" and the offer was refused as an
-// unsupported client version. Default it here instead, so a router that is
-// handed nothing behaves as the host it runs on. Injection stays available for
-// callers that need to judge against another platform.
-const HOST_PLATFORM = `${process.platform}-${process.arch}`;
-
-// evaluateVersionContract answers two different questions with one field.
-// "below_minimum_version", "known_bad_version", "version_unavailable" and
-// "prerelease_not_captured" are a capture reading the reported version and
-// refusing it. "platform_not_captured" is the opposite: a complete, valid
-// declaration that records nothing for the platform this router runs on. That
-// is not a malformed adapter, it is the ordinary shape of every shipped
-// adapter away from darwin-arm64 - the only platform any of them has captured
-// - so reading it as a refusal disables live delivery on Linux entirely.
-//
-// "native_delivery_unsupported" is absent deliberately: liveCapable already
-// required a nativeDelivery declaration before an offer was attempted, so the
-// contract check is never handed an adapter without one.
-const UNCAPTURED_PLATFORM = "platform_not_captured";
-
 // Compatibility was decided twice already - at bootstrap by the probe and at
 // SessionStart by the generation-bound handshake that published this binding.
 // The router validates binding identity and the adapter's answer; it does not
 // impose a third, exact-version rule that would reject a client the handshake
-// admitted.
+// admitted. The host it runs on is not asked either: a contract's minimum was
+// captured somewhere and applies everywhere.
 const liveCapable = (adapter, binding) => adapter !== undefined
   && adapter.capabilities?.delivery?.livePush === true
   && adapter.nativeDelivery !== undefined
@@ -68,8 +45,7 @@ function safeTransport(value, opaqueEndpointRef) {
   return opaqueEndpointRef === "live-adapter" ? "native-live" : "live-adapter";
 }
 
-export function createDeliveryRouter({ service, adapters, clock, platform = HOST_PLATFORM,
-  readLivePolicy }) {
+export function createDeliveryRouter({ service, adapters, clock, readLivePolicy }) {
   const registry = adaptersById(adapters);
 
   // Read at offer time, not from the binding: consent withdrawn after a session
@@ -139,7 +115,7 @@ export function createDeliveryRouter({ service, adapters, clock, platform = HOST
     const { adapter } = capable[0];
     if (Date.parse(binding.leaseUntil) <= Date.parse(now)) {
       const refreshed = await refreshExpiredBinding({ service, adapter, binding,
-        runtimeDir: service.store?.root, platform, clock });
+        runtimeDir: service.store?.root, clock });
       if (!refreshed) return durable(participantId, "recipient_unavailable");
       const current = (await service.listDeliveryBindings({
         participantId, now: clock.now() })).filter(item => item.sessionId === binding.sessionId
@@ -205,19 +181,11 @@ export function createDeliveryRouter({ service, adapters, clock, platform = HOST
     // Compatibility was already decided at bind time; a serving version that
     // still satisfies the adapter's captured contract keeps offering, even
     // when it differs from the value recorded when the binding was created.
-    // Only a version below the captured minimum or on the denylist refuses.
-    // When the contract captured nothing for this platform there is no
-    // minimum to judge against, so the offer keeps the rule this path had
-    // before the contract gate existed: the version that answered must be the
-    // one the binding recorded. defineAdapter rejecting a partial declaration
-    // does not make this unreachable - a complete, valid contract that names
-    // only darwin-arm64 says nothing about linux-x64, and that is every
-    // shipped adapter on Linux.
-    const versionRule = evaluateVersionContract(adapter, { clientVersion: response.clientVersion, platform });
-    const admitted = versionRule.reasonCode === null
-      || (versionRule.reasonCode === UNCAPTURED_PLATFORM
-        && response.clientVersion === binding.clientVersion);
-    if (!admitted) {
+    // Only a version below the captured minimum or on the denylist refuses,
+    // and a declaration that captured nothing refuses everything: a binding
+    // is not a capture.
+    const versionRule = evaluateVersionContract(adapter, { clientVersion: response.clientVersion });
+    if (versionRule.reasonCode !== null) {
       await recordFailure(binding, message, participantId, transport,
         "unsupported_client_version");
       return durable(participantId, "unsupported_client_version");

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

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