agents-can-communicate 0.7.1 → 0.8.1

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/managed-runtime/refresh.mjs

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { applyPlan, detectInstallation, livePolicyOf, loadOwnership, planInstallation, shellOf }
+import { applyPlan, detectInstallation, livePolicyOf, loadOwnership, planInstallation }
   from "@agents-can-communicate/installer";
 import { ALL_ADAPTERS, clientContext, probeTimeout } from "../install-command.mjs";
 import { stablePaths, writeLaunchers } from "./launchers.mjs";
@@ -17,7 +17,7 @@ export async function prepareRefresh({ control, root, env = process.env, callerP
   // session open across the update keeps running from the outgoing copy until it
   // restarts. Naming it here keeps that copy; everything older than it goes.
   const context = { ...clientContext(control.home, path.join(dataHome, "acc"),
-    { env, shell: shellOf(env), dataHome }), ...stablePaths(root),
+    { env, dataHome }), ...stablePaths(root),
   keepPreviousVersion: control.active.version };
   const recorded = (await loadOwnership({ dataHome })).installs;
   const detected = await detectInstallation({ adapters, context, probeTimeoutMs: probeTimeout(env) });
@@ -38,8 +38,7 @@ export async function prepareRefresh({ control, root, env = process.env, callerP
   }
   return async () => {
     await writeLaunchers(root, control.pending.root);
-    const result = await applyPlan({ plan, adapters, context, dataHome, accVersion: control.pending.version,
-      activation: { bootstrap: context.bootstrap } });
+    const result = await applyPlan({ plan, adapters, context, dataHome, accVersion: control.pending.version });
     return { ...result, failed: result.failed.map(failure => ({ ...failure,
       paths: plan.operations.find(operation => operation.adapterId === failure.adapterId)
         ?.artifacts?.map(artifact => artifact.path).filter(file => typeof file === "string") ?? [],

package/node_modules/@agents-can-communicate/cli/src/native-delivery-status.mjs

@@ -34,11 +34,11 @@ export function nativeRemediation(entry) {
       + "  # opt in to automatic peer requests; may spend tokens");
   } else if (native.configured && native.activation === "missing") {
     steps.push(`acc install --adapter ${entry.adapterId}`
-      + "  # complete the missing native launch setup from a supported shell");
+      + "  # complete the missing native delivery setup");
   } else if (native.configured && native.runtime !== "active"
     && !["needed", "blocked", "unsupported"].includes(service?.state)) {
     steps.push(`${entry.displayName}: no verified live channel in this workspace; `
-      + "open a new terminal, start a new client session and check its integration/channel prompts; "
+      + "start a new client session and check its integration prompts; "
       + "then run acc doctor here");
   }
   if (native.reasonCode === "native_endpoint_unavailable") {

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/core",
-  "version": "0.7.1",
+  "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/sessions.mjs

@@ -33,6 +33,9 @@ const ageBand = (session, age) =>
  * @returns {"online" | "stale" | "offline"}
  * @throws {AccError} EXIT.USAGE when pidIsAlive is not a function.
  */
+// A client's end reason is a short word of its own ("clear", "logout").
+const END_REASON = /^[a-z][a-z0-9_-]{0,63}$/;
+
 export function classifySessionPresence(session, now, pidIsAlive) {
   // Required rather than defaulted. A probe that defaults to "everyone is
   // alive" turns a forgotten call site into a check that silently passes, which
@@ -149,10 +152,14 @@ export function createSessionService(ports) {
     }, { kinds: ["session"] });
   }
 
-  async function closeSession({ sessionId, workspaceId, generation }) {
+  async function closeSession({ sessionId, workspaceId, generation, endReason = null }) {
+    // The client's own word for why, kept in extensions: an older ACC reading
+    // the same store skips them, and the session.closed event is unchanged.
+    const reason = typeof endReason === "string" && END_REASON.test(endReason) ? endReason : null;
     const close = current => {
       assertGeneration({ record: current }, generation, "close", workspaceId ?? store.workspaceId);
-      return { ...current, state: "closed", heartbeatAt: clock.now() };
+      return { ...current, state: "closed", heartbeatAt: clock.now(),
+        ...(reason === null ? {} : { extensions: { ...(current.extensions ?? {}), endReason: reason } }) };
     };
     let ephemeral = null;
     await store.ephemeral.delete("session", sessionId, async current => {
@@ -179,6 +186,21 @@ export function createSessionService(ports) {
     }, { kinds: ["session"] });
   }
 
+  /** The participant's most recent session, open or closed, or null. */
+  async function lastSessionOf({ participantId, workspaceId }) {
+    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");
+    const [last] = records.filter(session => session.participantId === participantId)
+      .sort((left, right) => Date.parse(right.heartbeatAt) - Date.parse(left.heartbeatAt)
+        || right.sessionId.localeCompare(left.sessionId));
+    return last === undefined ? null : { sessionId: last.sessionId, generation: last.generation,
+      state: last.state, endReason: last.extensions?.endReason ?? null };
+  }
+
   async function listLiveSessions({ participantId, workspaceId, now = clock.now() }) {
     const resolved = workspaceId ?? store.workspaceId;
     const snapshot = resolved === undefined ? null
@@ -198,6 +220,7 @@ export function createSessionService(ports) {
     resumeSession,
     heartbeatSession,
     closeSession,
+    lastSessionOf,
     listLiveSessions,
     locateSession: locate,
     ensureMaterialised: options => ensureMaterialised(ports, options),

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,7 +108,25 @@ 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
+    // the roster, by its latest session, so a sender can see where they went.
+    const liveParticipants = new Set(live.map(item => item.session.participantId));
+    const latest = new Map();
+    for (const { session } of classified) {
+      const seen = latest.get(session.participantId);
+      if (seen === undefined || Date.parse(session.heartbeatAt) > Date.parse(seen.heartbeatAt)) {
+        latest.set(session.participantId, session);
+      }
     }
+    const awaited = new Set([...latest.values()].filter(session => !liveParticipants.has(session.participantId)
+      && (waiting.get(session.participantId) ?? 0) > 0)
+      .map(session => session.sessionId));
 
     return {
       workspaceId,
@@ -115,7 +138,8 @@ export function createStatusService(ports, sessions, deliveryBindings) {
       // after a month of work this listed sixty entries for one live session.
       // `acc status --all` is how the worktree-cleanup question is asked.
       participants: classified
-        .filter(item => input.all === true || item.presence !== "offline")
+        .filter(item => input.all === true || item.presence !== "offline"
+          || awaited.has(item.session.sessionId))
         .map(({ session, presence }) => ({
         sessionId: session.sessionId,
         participantId: session.participantId,
@@ -132,6 +156,12 @@ export function createStatusService(ports, sessions, deliveryBindings) {
         intent: intents.find(intent => intent.sessionId === session.sessionId
           && isCurrentIntent(intent))?.summary ?? null,
         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.
+        // 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.7.1",
+  "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

@@ -5,7 +5,7 @@ import { refreshExpiredBinding } from "./refresh-binding.mjs";
 const SAFE_ERRORS = new Set(["ambiguous_recipient_sessions", "delivery_disabled",
   "recipient_busy", "recipient_unavailable", "transport_error", "transport_rejected", "transport_permission_denied",
   "unsupported_client_version"]);
-const NAMED_LIVE_TRANSPORTS = new Set(["claude-channel", "codex-app-server"]);
+const NAMED_LIVE_TRANSPORTS = new Set(["claude-inbox", "codex-app-server"]);
 
 const adaptersById = adapters => adapters instanceof Map
   ? adapters
@@ -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,14 +45,12 @@ 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
+  // bound must stop the next offer, not the next rebind.
   async function policyFor(adapter, binding) {
-    if (adapter?.nativeDelivery?.policySource !== "installation-record") {
-      return LIVE_POLICIES.has(binding.livePolicy) ? binding.livePolicy : "off";
-    }
     if (typeof readLivePolicy !== "function") return "off";
     try {
       const policy = await readLivePolicy({ adapter, binding });
@@ -101,7 +76,14 @@ export function createDeliveryRouter({ service, adapters, clock, platform = HOST
     // endpoint lease never sends a hook heartbeat: a daemon is reachability,
     // not evidence that this particular session thread is still present.
     const liveSessions = await service.listLiveSessions({ participantId, now });
-    if (liveSessions.length === 0) return durable(participantId, "recipient_unavailable");
+    if (liveSessions.length === 0) {
+      // No open session: the message waits until one starts or resumes. The
+      // client's own reason, when it gave one (Claude Code's /clear), is passed on.
+      const last = typeof service.lastSessionOf === "function"
+        ? await service.lastSessionOf({ participantId }).catch(() => null) : null;
+      return { ...durable(participantId, "recipient_offline"),
+        ...(last?.state === "closed" && typeof last.endReason === "string" ? { endReason: last.endReason } : {}) };
+    }
     if (liveSessions.length > 1) {
       return durable(participantId, "ambiguous_recipient_sessions");
     }
@@ -110,7 +92,9 @@ export function createDeliveryRouter({ service, adapters, clock, platform = HOST
       participantId, now, includeExpired: true }))
       .filter(binding => binding.sessionId === target.sessionId
         && binding.generation === target.generation);
-    if (bindings.length === 0) return durable(participantId, "recipient_unavailable");
+    // Online, with nothing to push through: a CLI participant, or a client
+    // that bound no live transport. It reads its inbox, so it is not gone.
+    if (bindings.length === 0) return durable(participantId, "no_live_transport");
     const evaluated = await Promise.all(bindings.map(async binding => {
       const adapter = registry.get(binding.adapterId);
       return { binding, adapter, policy: await policyFor(adapter, binding) };
@@ -118,7 +102,7 @@ export function createDeliveryRouter({ service, adapters, clock, platform = HOST
     const permitted = evaluated.filter(({ policy }) => permits(policy, 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");
+    if (reachable.length === 0) return durable(participantId, "no_live_transport");
     const capable = reachable.filter(({ binding, adapter }) => liveCapable(adapter, binding));
     if (capable.length === 0) {
       return durable(participantId, "unsupported_client_version");
@@ -131,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
@@ -197,23 +181,24 @@ 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");
     }
+    // A wake put a notice in front of the client, not the body. Recording it
+    // as offered would make the next-turn projection treat the body as already
+    // shown and leave it out of the very turn the wake started. The receipt
+    // stays queued; the hook records the offer once its stdout carried the body.
+    if (adapter.nativeDelivery?.offerKind === "wake") {
+      // The client took the wake but holds it for its user's approval.
+      return { recipientParticipantId: participantId, outcome: "woken", transport,
+        ...(response.pendingApproval === true ? { pendingApproval: true } : {}) };
+    }
     try {
       await service.recordOfferSucceeded({ messageId: message.messageId,
         recipientParticipantId: participantId, targetSessionId: binding.sessionId,

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/hook-runner",
-  "version": "0.7.1",
+  "version": "0.8.1",
   "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-attempt.mjs

@@ -1,7 +1,7 @@
 import { storeNativeAttempt } from "@agents-can-communicate/adapter-sdk";
 import { readInstalledLivePolicyState } from "@agents-can-communicate/installer";
 
-import { establishNativeBinding, LIVE_POLICIES, livePolicyFrom } from "./native-binding.mjs";
+import { establishNativeBinding } from "./native-binding.mjs";
 
 // A cold worker plus the write has to finish inside this window. 250 ms was
 // not enough on a busy CI runner, so the attempt file never appeared and
@@ -27,13 +27,11 @@ export async function bindNative({ adapter, event, hookBinding, clientVersion, p
     if (Date.now() >= deadline) throw new Error("hook deadline expired");
   };
   assertBudget();
-  const policySource = adapter?.nativeDelivery?.policySource === "installation-record"
-    ? "installation-record" : "bootstrap-environment";
-  const raw = context.env?.ACC_NATIVE_DELIVERY_POLICY;
-  const { policy, policyStatus } = policySource === "installation-record"
-    ? await readInstalledLivePolicyState({ dataHome: context.dataHome, adapterId: adapter.id })
-    : { policy: livePolicyFrom(context.env), policyStatus: raw === undefined ? "missing"
-      : !LIVE_POLICIES.includes(raw) ? "invalid" : raw === "off" ? "off" : "enabled" };
+  // The install record is the only consent a hook reads; see
+  // validateNativeDeliveryContract for the environment source this replaced.
+  const policySource = "installation-record";
+  const { policy, policyStatus } = await readInstalledLivePolicyState({ dataHome: context.dataHome,
+    adapterId: adapter.id });
   assertBudget();
   const result = await establishNativeBinding({ adapter, event, hookBinding, clientVersion, platform,
     livePolicy: policy, service: context.service, runtimeDir: paths.root,

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

@@ -16,19 +16,24 @@ 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"]);
-
-// Only the value a successful owned shell bootstrap exported counts; anything
-// else - missing, blank, differently cased, a number - is off.
-export function livePolicyFrom(env) {
-  const value = env?.ACC_NATIVE_DELIVERY_POLICY;
-  return LIVE_POLICIES.includes(value) ? value : "off";
-}
+const STATIC_REASONS = new Set(["native_delivery_unsupported", "version_unavailable",
+  "below_minimum_version", "known_bad_version"]);
 
 const isPid = value => Number.isInteger(value) && value > 0;
 
+// An adapter may write its private endpoint before the static rule below judges
+// the handshake, or after this hook stopped waiting. Nothing publishes such an
+// endpoint, so nothing would ever retire it, and a refused client binds again
+// on every turn. Fail-open and never awaited past the adapter's own answer.
+function discardEndpoint(adapter, handshake, runtimeDir) {
+  const opaqueEndpointRef = handshake?.opaqueEndpointRef;
+  if (typeof opaqueEndpointRef !== "string" || opaqueEndpointRef === ""
+    || typeof adapter?.retireNativeSession !== "function") return Promise.resolve();
+  return Promise.resolve().then(() => adapter.retireNativeSession({
+    binding: { opaqueEndpointRef, clientVersion: handshake.clientVersion ?? null }, runtimeDir }))
+    .catch(() => {});
+}
+
 export async function establishNativeBinding({ adapter, event, hookBinding, clientVersion,
   platform, livePolicy, service, runtimeDir, clock, env,
   timeoutMs = DEFAULT_TIMEOUT_MS, heartbeatCadenceMs = DEFAULT_CADENCE_MS }) {
@@ -57,16 +62,23 @@ export async function establishNativeBinding({ adapter, event, hookBinding, clie
   let timer = null;
   try {
     const budget = Math.max(1, Math.floor(timeoutMs));
+    const pending = Promise.resolve().then(() => adapter.bindNativeSession({ event, clientPid,
+      clientVersion, runtimeDir, timeoutMs: budget, env }));
+    // An answer that lands after the budget has nobody left to use it.
+    let timedOut = false;
+    pending.then(late => { if (timedOut) discardEndpoint(adapter, late, runtimeDir); }, () => {});
     const handshake = await Promise.race([
-      adapter.bindNativeSession({ event, clientPid, clientVersion, runtimeDir,
-        timeoutMs: budget, env }),
+      pending,
       new Promise((_resolve, reject) => {
-        timer = setTimeout(() => reject(Object.assign(new Error("native handshake timed out"),
-          { code: "ETIMEDOUT" })), budget);
+        timer = setTimeout(() => {
+          timedOut = true;
+          reject(Object.assign(new Error("native handshake timed out"), { code: "ETIMEDOUT" }));
+        }, 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",
         verdict.reasonCode);
     }