agents-can-communicate 0.8.0 → 0.8.2

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

@@ -16,7 +16,7 @@ const usage = message => new AccError(EXIT.USAGE, message);
 import { commandHelpText, describeCommand, describeCommands, helpText } from "./help.mjs";
 import { runUpdateCommand } from "./update-command.mjs";
 import { runConfigCommand } from "./config-command.mjs";
-import { runInstallCommand } from "./install-command.mjs";
+import { ALL_ADAPTERS, runInstallCommand } from "./install-command.mjs";
 import { runDoctor } from "./doctor-command.mjs";
 import { runManagementDoctor } from "./managed-runtime/diagnostics.mjs";
 import { createGitProbe } from "./git-probe.mjs";
@@ -179,12 +179,49 @@ export async function recordAndOffer({ record, router, selectMessage = value =>
   }
 }
 
-/** How many are here, and how many only look it. */
-export function describePresence({ live = 0, stale = 0 } = {}) {
+/**
+ * What a message sent to each stale session would meet.
+ *
+ * Presence reads the client process, so a dead one is offline and a stale
+ * session with a live process is idle. Idle is then told apart by delivery: a
+ * live binding wakes it, a client with next-turn delivery shows the message on
+ * its next turn, and anything else reads it through `acc inbox`. A session with
+ * no known process cannot be told from one that left, so it is not answering.
+ *
+ * A live binding wakes on the router's own rule: a current lease, or a lapsed
+ * one the adapter can re-verify. Without that the next send is durable.
+ */
+export function presenceBreakdown(participants = [], adapters = ALL_ADAPTERS()) {
+  const nextTurn = new Set(adapters.filter(adapter => adapter.capabilities?.delivery?.nextTurn === true)
+    .map(adapter => adapter.id));
+  const refreshes = new Set(adapters.filter(adapter => typeof adapter.refreshNativeSession === "function")
+    .map(adapter => adapter.id));
+  const wakes = participant => participant.liveDelivery === true
+    && (participant.liveLeaseCurrent === true || refreshes.has(participant.harness));
+  const idle = { wake: 0, nextTurn: 0, inbox: 0, unknown: 0 };
+  for (const participant of participants.filter(item => item.presence === "stale")) {
+    const kind = participant.processTracked !== true ? "unknown"
+      : wakes(participant) ? "wake"
+        : nextTurn.has(participant.harness) ? "nextTurn" : "inbox";
+    idle[kind] += 1;
+  }
+  return idle;
+}
+
+/**
+ * How many are here, and what a message would meet with those not active.
+ * Without a breakdown every stale session counts as not answering, the answer
+ * before presence could tell an idle session from one whose client had left.
+ */
+export function describePresence({ live = 0, stale = 0 } = {},
+  idle = { wake: 0, nextTurn: 0, inbox: 0, unknown: stale }) {
   if (live === 0) return "0 live";
   if (stale === 0) return `${live} live`;
-  if (stale === live) return `${live} present, none answering`;
-  return `${live} live (${stale} not answering)`;
+  if (idle.unknown === live) return `${live} present, none answering`;
+  const parts = [[idle.wake, "idle, wake on send"], [idle.nextTurn, "idle until next turn"],
+    [idle.inbox, "idle, inbox only"], [idle.unknown, "not answering"]]
+    .filter(([count]) => count > 0).map(([count, text]) => `${count} ${text}`);
+  return `${live} live (${parts.join("; ")})`;
 }
 
 export function describeStatus(status) {
@@ -193,19 +230,19 @@ export function describeStatus(status) {
   // stops being answered but does not disappear. Printing the number alone
   // said "1 live" about a workspace where the last agent had left minutes
   // before, which is the one thing a person reads this line to find out.
-  const line = `${describePresence(status.counts)}; ${status.counts.claims} claim(s); `
+  const line = `${describePresence(status.counts, presenceBreakdown(status.participants))}; `
+    + `${status.counts.claims} claim(s); `
     + `protection ${status.protection}`;
   // A transport accepting a message is not a model reading it. Said only when
   // it is true of something, so the everyday line stays the everyday line.
   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/cli/src/native-session-diagnostics.mjs

@@ -60,14 +60,19 @@ export async function updateNativeSessions(adapters, { service, status, root, no
         && b.availableModes.includes("livePush"));
       const off = native.policySource === "installation-record" && !native.configured;
       const leased = binding !== undefined && Date.parse(binding.leaseUntil) > Date.parse(now);
-      // Only where the old rule would have said "active": everywhere else the
-      // answer is already degraded or unbound, and a live check would buy
-      // nothing but a socket round trip.
-      const delivery = off || !leased ? null
+      // A lapsed lease is asked about too. Nothing renews it while a session
+      // sits idle, and the router does not refuse it: it re-verifies the
+      // receiver and refreshes the lease before it offers. Stopping at the
+      // lease reported sessions that answered a live question in seconds as
+      // degraded, with advice to start a new one.
+      const delivery = off || binding === undefined ? null
         : await verifyDelivery(byAdapterId.get(entry.adapterId), { binding, runtimeDir: root });
+      // Without a re-verification the router cannot refresh a lapsed lease
+      // either, so only a live lease keeps the old answer.
       const runtime = off ? "inactive"
         : binding === undefined ? "unbound"
-          : leased && (delivery === null || delivery.deliverable) ? "active" : "degraded";
+          : delivery === null ? (leased ? "active" : "degraded")
+            : !delivery.deliverable ? "degraded" : leased ? "active" : "idle";
       native.sessions.push({ sessionId: peer.sessionId, participantId: peer.participantId,
         presence: peer.presence, runtime, clientVersion: binding?.clientVersion ?? null, delivery,
         lastAttempt: owner === null ? null : await loadNativeAttempt({ runtimeDir: root, ...owner }) });
@@ -76,10 +81,13 @@ export async function updateNativeSessions(adapters, { service, status, root, no
     // one claiming health while nothing could be delivered. If this adapter
     // has bound sessions in this workspace and not one of them can take a
     // push, this is not an active transport.
-    if (native.runtime === "active" && native.sessions.length > 0
-      && !native.sessions.some(session => session.runtime === "active")) {
+    const reachable = native.sessions.some(session => ["active", "idle"].includes(session.runtime));
+    if (native.runtime === "active" && native.sessions.length > 0 && !reachable) {
       native.runtime = "degraded";
     }
+    // The other direction, which the binding pass cannot see: it reads a
+    // lapsed lease as unreachable, and a receiver that answered says otherwise.
+    if (native.runtime === "degraded" && reachable) native.runtime = "active";
   }
 }
 
@@ -131,10 +139,12 @@ function describeDelivery(session) {
     : "receiver verified";
 }
 
+const RUNTIME_TEXT = { active: "local transport active", idle: "idle, lease lapsed" };
+
 export function nativeSessionLines(adapters) {
   return adapters.flatMap(entry => (entry.nativeDelivery.sessions ?? []).map(session =>
     `  ${entry.displayName} session ${session.participantId} (${session.sessionId}): `
-    + `${session.runtime === "active" ? "local transport active" : session.runtime}; `
-    + [describeDelivery(session), describeAttempt(session.lastAttempt)]
-      .filter(part => part !== null).join("; ")));
+    + `${RUNTIME_TEXT[session.runtime] ?? session.runtime}; `
+    + [describeDelivery(session), session.runtime === "idle" ? "the next send refreshes it" : null,
+      describeAttempt(session.lastAttempt)].filter(part => part !== null).join("; ")));
 }

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.2",
   "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.
@@ -88,6 +89,12 @@ export function createStatusService(ports, sessions, deliveryBindings) {
     const claims = snapshot.claims
       .filter(claim => Date.parse(claim.expiresAt) > Date.parse(now));
     const currentBindings = await deliveryBindings.currentBindings(now);
+    // A live binding and its lease are reported apart. The router refreshes a
+    // lapsed lease only through the adapter's own re-verification, and which
+    // adapters have one is not a fact core may know, so the reader decides.
+    const liveBound = new Map(currentBindings
+      .filter(({ binding }) => binding.availableModes.includes("livePush"))
+      .map(({ binding, reachable }) => [binding.sessionId, reachable]));
     // What each recipient has not fetched yet, and how far it got. Offered is
     // not read: a transport took the bytes. Queued sits beside it so "0
     // offered" cannot be mistaken for "nothing waits". Replaced decisions
@@ -96,6 +103,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 +114,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 +131,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 {
@@ -141,6 +156,12 @@ export function createStatusService(ports, sessions, deliveryBindings) {
         enforcement: session.enforcement ?? "advisory",
         lifecycle: session.lifecycle ?? "manual",
         presence,
+        // What a stale presence means depends on these. With the process known,
+        // stale is idle, since a dead process is offline; with a live binding,
+        // a push can wake it. Only a session nobody can observe is not answering.
+        processTracked: (session.pid ?? null) !== null,
+        liveDelivery: liveBound.has(session.sessionId),
+        liveLeaseCurrent: liveBound.get(session.sessionId) === true,
         // A finished intent reads as no intent at all. `--clear` exists so a
         // peer stops seeing work that has stopped, and reporting the summary of
         // a done record made the command and this line contradict each other.
@@ -149,7 +170,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.2",
   "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.2",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -4,6 +4,35 @@ import path from "node:path";
 // enough that a table which disagrees with itself cannot spin.
 const MAX_HOPS = 16;
 
+// A client shipped as a node script runs as `node`, so its comm names the
+// interpreter. Gemini CLI is one, measured on 0.60.0. For these, the script the
+// interpreter was given names the client.
+const SCRIPT_HOSTS = new Set(["node"]);
+const SCRIPT_EXTENSION = /\.[mc]?js$/;
+
+/** What the script a script host runs could be called, without extensions. */
+function scriptsOf(entry) {
+  if (!SCRIPT_HOSTS.has(path.basename(entry.comm)) || typeof entry.args !== "string") return [];
+  // `args` starts with the interpreter as it was invoked, which is the comm
+  // itself on macOS; past it, the first word that is no option is the script -
+  // unless an option written without `=` came right before it, since that word
+  // may be the option's value (`--require ./preload.cjs`). Which options take
+  // one depends on the client's own node, so such a word is kept as a candidate
+  // and the search goes on; it ends at the first word no bare option precedes.
+  const rest = entry.args.startsWith(`${entry.comm} `) ? entry.args.slice(entry.comm.length)
+    : entry.args.replace(/^\S+/, "");
+  const candidates = [];
+  let afterBareOption = false;
+  for (const word of rest.trim().split(/\s+/)) {
+    if (word === "") continue;
+    if (word.startsWith("-")) { afterBareOption = !word.includes("="); continue; }
+    candidates.push(path.basename(word).replace(SCRIPT_EXTENSION, ""));
+    if (!afterBareOption) break;
+    afterBareOption = false;
+  }
+  return candidates;
+}
+
 /**
  * The pid of the client this hook is running for, or null when nobody knows.
  *
@@ -24,7 +53,7 @@ export function resolveClientPid({ table, from, command, maxHops = MAX_HOPS }) {
     seen.add(current);
     // `ps` reports some entries bare (`claude`) and some with a path
     // (`/bin/zsh`), so the comparison has to be on the basename.
-    if (path.basename(entry.comm) === command) return current;
+    if (path.basename(entry.comm) === command || scriptsOf(entry).includes(command)) return current;
     if (entry.ppid === current || entry.ppid <= 1) return null;
     current = entry.ppid;
   }

package/node_modules/@agents-can-communicate/hook-runner/src/native-binding.mjs

@@ -16,9 +16,8 @@ const DEFAULT_CADENCE_MS = 60_000;
 
 // Reasons the static rule refused: the client will not change within the
 // session, so the state is "unsupported" rather than a retryable "degraded".
-const STATIC_REASONS = new Set(["native_delivery_unsupported", "platform_not_captured",
-  "version_unavailable", "prerelease_not_captured", "below_minimum_version",
-  "known_bad_version"]);
+const STATIC_REASONS = new Set(["native_delivery_unsupported", "version_unavailable",
+  "below_minimum_version", "known_bad_version"]);
 
 const isPid = value => Number.isInteger(value) && value > 0;
 
@@ -77,7 +76,7 @@ export async function establishNativeBinding({ adapter, event, hookBinding, clie
         }, budget);
       }),
     ]);
-    const verdict = validateNativeHandshake(adapter, { clientVersion, platform, handshake });
+    const verdict = validateNativeHandshake(adapter, { clientVersion, handshake });
     if (!verdict.ok) {
       await discardEndpoint(adapter, handshake, runtimeDir);
       return outcome(STATIC_REASONS.has(verdict.reasonCode) ? "unsupported" : "degraded",

package/node_modules/@agents-can-communicate/hook-runner/src/process-table.mjs

@@ -8,27 +8,43 @@ const run = promisify(execFile);
 const DEFAULT_TIMEOUT_MS = 1_000;
 
 const LINE = /^\s*(\d+)\s+(\d+)\s+(.+?)\s*$/;
+// A pid, then the whole rest of the line: a command line has spaces anywhere.
+const ARGS_LINE = /^\s*(\d+)\s+(.+?)\s*$/;
+// Command lines are long; measured at 231 KB for 1,137 processes on a desktop
+// Mac, a quarter of execFile's default buffer.
+const ARGS_BUFFER = 16 * 1024 * 1024;
 
 /**
- * Every process on this machine, as pid -> parent and executable.
+ * Every process on this machine, as pid -> parent, executable and, when it
+ * could be read, command line.
  *
  * Returns an empty map rather than throwing when the platform has no `ps`
  * (Windows) or the call fails. An empty table resolves no client, which is the
- * "nobody knows" answer the caller already handles.
+ * "nobody knows" answer the caller already handles. The command lines are read
+ * at the same time and within the same timeout; they only name a client that
+ * is a script, so when that read fails every entry keeps what it had before.
  */
 export async function readProcessTable({ run: exec = run,
   timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
-  try {
-    const { stdout } = await exec("ps", ["-o", "pid=,ppid=,comm=", "-A"],
-      { timeout: timeoutMs, killSignal: "SIGKILL" });
-    const table = new Map();
-    for (const line of stdout.split("\n")) {
-      const match = LINE.exec(line);
-      if (match === null) continue;
-      table.set(Number(match[1]), { ppid: Number(match[2]), comm: match[3] });
-    }
-    return table;
-  } catch {
-    return new Map();
+  const options = { timeout: timeoutMs, killSignal: "SIGKILL" };
+  const [tree, commandLines] = await Promise.all([
+    exec("ps", ["-o", "pid=,ppid=,comm=", "-A"], options).then(({ stdout }) => stdout, () => null),
+    exec("ps", ["-A", "-o", "pid=,args="], { ...options, maxBuffer: ARGS_BUFFER })
+      .then(({ stdout }) => stdout, () => ""),
+  ]);
+  if (typeof tree !== "string") return new Map();
+  const args = new Map();
+  for (const line of String(commandLines).split("\n")) {
+    const match = ARGS_LINE.exec(line);
+    if (match !== null) args.set(Number(match[1]), match[2]);
   }
+  const table = new Map();
+  for (const line of tree.split("\n")) {
+    const match = LINE.exec(line);
+    if (match === null) continue;
+    const pid = Number(match[1]);
+    table.set(pid, { ppid: Number(match[2]), comm: match[3],
+      ...(args.has(pid) ? { args: args.get(pid) } : {}) });
+  }
+  return table;
 }

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

@@ -400,8 +400,10 @@ const HANDLERS = {
       const facts = await runtimeFacts(import.meta.url);
       await storeSessionBinding({ runtimeDir: paths.root, deadlineAt: deadline, harnessSessionId: event.sessionId,
         accSessionId: binding.accSessionId, generation: binding.generation, ...facts });
+      // The pid this binding already knew keeps the refreshed pin reapable if
+      // the lookup below cannot find the client.
       await writePin({ root: pinRoot, harnessSessionId: event.sessionId, runtimeRoot: facts.runtimeRoot,
-        version: facts.version, storeVersion: facts.storeVersion });
+        version: facts.version, storeVersion: facts.storeVersion, clientPid: binding.clientPid });
     }
     const clientVersion = await probeClientVersion(adapter,
       { timeoutMs: Math.max(1, Math.min(1_000, deadline - Date.now())) });
@@ -600,6 +602,15 @@ const HANDLERS = {
   async beforeTool({ binding, context, event, adapter }) {
     if (binding === null) return { decision: "allow" };
     if (event.targets.length === 0) {
+      // A shell command is work too. The refresh below sat behind the write
+      // guard, so a turn spent in the shell went stale three minutes in, measured
+      // on 0.8.1. With no guard read to borrow from, the session's own record is
+      // the narrow read that says whether a heartbeat is due.
+      const own = await context.service.locateSession(binding.accSessionId).catch(() => null);
+      if (own !== null && needsRefresh(own.record.heartbeatAt, Date.now())) {
+        await context.service.heartbeatSession({ sessionId: binding.accSessionId,
+          generation: binding.generation }).catch(() => null);
+      }
       // The runner cannot tell what a shell command touches. Saying so is the
       // honest answer; guessing would block work at random and miss real writes.
       return { decision: "allow", unguarded: true };