agents-can-communicate 0.8.0 → 0.8.1

package/bin/entrypoints/acc-mcp.mjs

@@ -54,7 +54,6 @@ await serve({
   context: {
     service,
     deliveryRouter: createDeliveryRouter({ service, adapters, clock,
-      platform: `${process.platform}-${process.arch}`,
       readLivePolicy: ({ adapter }) => readInstalledLivePolicy({ dataHome,
         adapterId: adapter.id }) }),
     workspaceId: descriptor.id,

package/bin/entrypoints/acc.mjs

@@ -25,7 +25,6 @@ const runtime = {
   ids: { next: kind => createId(kind, randomBytes) },
   createDeliveryRouter: ({ service, clock, dataHome }) =>
     createDeliveryRouter({ service, adapters, clock,
-      platform: `${process.platform}-${process.arch}`,
       readLivePolicy: ({ adapter }) => readInstalledLivePolicy({ dataHome,
         adapterId: adapter.id }) }),
   // Asked only by `acc config init`, and only when stdout is a terminal. There

package/docs/ADAPTER_AUTHORING.md

@@ -81,10 +81,15 @@ is not evidence for compaction. Counts add no ids to `offeredMessageIds` or
 
 `client.command` does double duty. `detect.mjs` uses it as the version-probe binary, and
 presence liveness separately walks the hook's process ancestry for the first ancestor whose
-executable basename matches it, to learn the client's own pid. Declare the binary the client
-actually runs as — `command: "claude"` for a client that really runs as `node` resolves
-nothing, and the failure is silent: the session gets `pid: null` and falls back to reading
-presence by age alone, with nothing telling you why.
+executable basename matches it, to learn the client's own pid. A client shipped as a node
+script, such as Gemini CLI, runs as `node`; for a `node` ancestor the walk also matches the
+script it runs: the first argument after any interpreter options, by basename, with a
+`.js`, `.mjs` or `.cjs` extension ignored. A word right after an option written without `=`
+may be that option's value (`--require ./preload.cjs`), so it is also tried and the script
+after it still counts. Declare the name the client actually runs as. A
+command that matches neither resolves nothing, and the failure is silent: the session gets
+`pid: null`, falls back to reading presence by age alone, and is not pinned to its
+generation, with nothing telling you why.
 
 ## Declare only proven capabilities
 
@@ -148,9 +153,8 @@ to its capabilities:
 
 ```js
 nativeDelivery: {
-  minimumByPlatform: { "darwin-arm64": "2.1.282" },
-  anchors: [{ platform: "darwin-arm64", version: "2.1.282",
-    protocolContract: "claude-code-inbox-socket-v1" }],
+  minimum: "2.1.282",
+  anchors: [{ version: "2.1.282", protocolContract: "claude-code-inbox-socket-v1" }],
   knownBad: [],
   activationKinds: ["native-service"],
   offerKind: "wake",
@@ -159,17 +163,32 @@ nativeDelivery: {
 
 The rules `defineAdapter` enforces, and the ones the runtime applies:
 
-- A minimum is the **first passing capture** on that platform, never a guessed first vendor
-  release. Every anchor must have passing `delivery.livePush` evidence for the same client,
-  version, and platform, and each minimum must itself be an anchor.
-- There is intentionally **no maximum version**. A newer stable release is admitted only
-  when a current read-only feature probe (`probeNativeDelivery()`) and a per-session
-  handshake (`bindNativeSession()`) both report the anchored `protocolContract`;
-  `evaluateNativeEligibility()` and `validateNativeHandshake()` are those two checks.
-- Prereleases require their own passing capture; they are `prerelease_not_captured` even
-  when numerically newer. `knownBad` names exact versions or inclusive intervals.
-- Exact-version certification still governs every non-native capability;
+- The minimum is the **first passing capture**, never a guessed first vendor release. Every
+  anchor must have passing `delivery.livePush` evidence for the same client and version, and
+  the minimum must itself be an anchor. The platform an evidence row names is where the
+  capture was taken; it is provenance, and the anchor names no platform.
+- There is intentionally **no maximum version** and **no platform**. A newer release is
+  admitted, on every platform, only when a current read-only feature probe
+  (`probeNativeDelivery()`) and a per-session handshake (`bindNativeSession()`) both report
+  the anchored `protocolContract`; `evaluateNativeEligibility()` and
+  `validateNativeHandshake()` are those two checks.
+- A prerelease is judged by its release triple, as hook capabilities are: `2.2.0-beta.1` is
+  `2.2.0` against the minimum and `knownBad`. `knownBad` names exact versions or inclusive
+  intervals. A version that cannot be read at all is `version_unavailable`.
+- Certification evidence still governs every non-native capability;
   `effectiveCapabilities()` is unchanged. The native rule is used for live delivery alone.
+
+What may refuse live delivery is exactly three things:
+
+- the machine's own probe or per-session handshake failing;
+- a client older than the first passing capture;
+- a regression recorded in `knownBad`.
+
+Nothing else: not the platform, not a prerelease suffix, not where the evidence was taken. A
+transport that is technically different on some platform is the probe's fact to report, as
+`native_delivery_unsupported`, never a gap in the captures. The 0.8.0 shape,
+`minimumByPlatform` with a platform on each anchor, is refused by name; the design record is
+`docs/design/2026-09-26-native-delivery-across-platforms.md` in the repository.
 - Native methods return closed facts (`validateNativeActivationPlan()` closes the
   activation plan) and never put vendor data - endpoints, sockets, raw errors - into core.
 

package/docs/ARCHITECTURE.md

@@ -107,8 +107,9 @@ turn.
 
 The Claude Code inbox wake has installed-client evidence on 2.1.282. Codex LocalDaemon
 has it on 0.152.1 and 0.153.4. Antigravity CLI has it on 1.2.7 and later through a relay
-the agent starts in its own shell. All three use a captured platform minimum,
-current probe and exact session handshake. Claude Code and Codex preserve the ordinary
+the agent starts in its own shell. All three use a captured minimum that applies on every
+platform, a current probe and an exact session handshake; a prerelease is judged by its
+release triple. Claude Code and Codex preserve the ordinary
 client launch. Claude Code verifies its session registry, and Codex verifies its registered
 thread and workspace. Native delivery owns no vendor daemon lifecycle. Gemini CLI and Kimi
 Code have exact-version next-turn evidence only. Grok and generic MCP use inbox polling.
@@ -226,10 +227,12 @@ modes. It preserves explicit declarations and does not rewrite live leases. Miss
 changed generation files and unknown native bindings remain unverified holds.
 A session is also pinned to the generation
 it started with: its hooks delegate to that generation while the pin declares the same
-store contract this one does, and run the active generation otherwise. A generation
-directory is reclaimed once no control pointer, live lease, live pin or staging hold names
-it. Parsed help, version, and update recovery remain available when workspace admission is
-unavailable.
+store contract this one does, and run the active generation otherwise. Apart from
+`SessionEnd`, only the client's confirmed death releases a pin, so a session whose client
+process cannot be found is not pinned, and a pin that names no client is reaped. A
+generation directory is reclaimed once no control pointer, live lease, live pin or staging
+hold names it. Parsed help, version, and update recovery remain available when workspace
+admission is unavailable.
 
 An independent worker downloads npm packages with lifecycle scripts disabled, checks exact
 stable package identity and the discovered integrity, and health-checks the staged runtime.

package/docs/CAPABILITIES.md

@@ -20,9 +20,9 @@ Capability honesty separates four questions that are easy to collapse:
 A source method or vendor documentation is not certification. A capture applies forward: from
 the version that recorded it until a later capture changes that capability, and to every
 platform until one of them records something of its own. A client older than every capture
-degrades to false, and so does a capability a capture recorded as failing. Native
-minimum-based eligibility is separate, and stays per-platform. No weaker session inherits a
-stronger peer's capability.
+degrades to false, and so does a capability a capture recorded as failing. Native live
+delivery reads its captured minimum the same way: on every platform, with a prerelease judged
+by its release triple. No weaker session inherits a stronger peer's capability.
 
 Run `acc doctor` in the project when observed behavior differs from this page. It reports
 the installed client version, platform, effective capability, and fallback instead of
@@ -53,9 +53,18 @@ The native rows are `no` at the hook versions this matrix names.
 Separate installed-client captures establish Codex `livePush` on 0.152.1 and
 0.153.4, Claude Code `livePush` on 2.1.282 through the session inbox, and
 Antigravity CLI `livePush` on 1.2.7 and later through a relay the agent starts in its own shell.
-Native eligibility uses the captured platform minimum, a current feature probe,
-and an exact per-session handshake. It is experimental and requires recipient
-opt-in. Codex, Claude Code and Antigravity CLI reply through `acc reply`. Their native
+Native eligibility uses the captured minimum, a current feature probe, and an exact
+per-session handshake. It is experimental and requires recipient opt-in.
+
+What may refuse live delivery is exactly three things:
+
+- the machine's own probe or per-session handshake failing;
+- a client older than the first passing capture;
+- a regression recorded in `knownBad`.
+
+Nothing else: not the platform, not a prerelease suffix, not where the evidence was taken.
+A platform whose transport is technically different is refused by the probe as a fact about
+that transport, which is what Claude Code's named pipe on native Windows is. Codex, Claude Code and Antigravity CLI reply through `acc reply`. Their native
 `replyRoute` remains false.
 
 The limitations belong next to the adapters they affect:
@@ -64,7 +73,7 @@ The limitations belong next to the adapters they affect:
 |---|---|
 | Antigravity CLI | 1.2.7 on darwin-arm64, captured in print mode, and every later release by the forward rule. Only `SessionStart`, `PreInvocation`, `PostInvocation` and `Stop` load; `SessionEnd`, `PreToolUse` and `PostToolUse` are accepted into the config file and silently dropped, so there is no tool guard and no session-end deregistration - a session goes offline by presence age or an explicit `acc finish`. Payloads carry no `hook_event_name`, so each registered command passes its own event name. The end-of-turn `Stop` continuation reaches the model and is a bounded nudge, not a gate: ACC continues a turn at most once and fails open, and the client caps consecutive continuations itself (vendor 1.1.9). `agy agentapi send-message` can wake an idle session - captured - but only with that session's language-server address and CSRF token, which exist in the agent's own shell and in no hook. ACC does not take that token, so live push and reply routing are false. A peer message that arrives while the model writes its last answer is carried by the `Stop` continuation instead. A write that parses can register nothing, so install and doctor read `agy -p "/hooks"` back instead of trusting the file. Live push (1.2.7, darwin-arm64, TUI only, experimental, recorded opt-in) runs through a relay the agent starts once per conversation from its own shell - the only process holding the session endpoint - after ACC's context asks it to, up to three times while none is serving; the operator approves that command at the client's permission prompt. An idle session wakes; a busy one sees the message after its running answer, or at the next model invocation when the turn waits on a tool. Print mode and the first session in a folder trusted at that launch get no relay. |
 | Codex | Next-turn context, captured on 0.147.0, requires plugin trust. The observed stock 0.153.4 upgrade from ACC 0.3.1 to 0.4 required fresh review of five modified hook definitions; a subsequent restart retained all five active (activation evidence, not new event certification). LocalDaemon native delivery was captured through the installed package on 0.152.1 and 0.153.4, darwin-arm64; minimum 0.152.1, recorded opt-in, current feature probe and exact thread/cwd/process/version/protocol checks are required. Ordinary launch preserves the receiver workspace without ACC arguments or daemon ownership. Embedded or unreachable sessions keep their inbox. Native `replyRoute` remains false. |
-| Claude Code | 2.1.233 next-turn delivery waits for the next user prompt. From 2.1.282 on darwin-arm64, `delivery.livePush` is a live capability behind the native contract (experimental, off until opted in). ACC wakes the session through the inbox socket that Claude Code opens for every session, with one line of fixed ACC text and the message id. An idle session starts a turn. A busy session takes the wake between two tool calls. Each delivered wake fires `UserPromptSubmit`, so the next-turn hook shows the body and records the receipt `offered` via `next-turn`. The model answers with `acc reply`, so `delivery.replyRoute` stays false. A session in `bypassPermissions` mode holds each wake for approval unless `crossSessionInbound` is `accept`, and `refuse` drops wakes. Native Windows keeps next-turn delivery: its inbox is a named pipe that requires an auth line, and it is uncaptured. Linux is uncaptured. |
+| Claude Code | 2.1.233 next-turn delivery waits for the next user prompt. From 2.1.282, captured on darwin-arm64 and applied on every platform whose inbox is a Unix socket, `delivery.livePush` is a live capability behind the native contract (experimental, off until opted in). ACC wakes the session through the inbox socket that Claude Code opens for every session, with one line of fixed ACC text and the message id. An idle session starts a turn. A busy session takes the wake between two tool calls. Each delivered wake fires `UserPromptSubmit`, so the next-turn hook shows the body and records the receipt `offered` via `next-turn`. The model answers with `acc reply`, so `delivery.replyRoute` stays false. A session in `bypassPermissions` mode holds each wake for approval unless `crossSessionInbound` is `accept`, and `refuse` drops wakes. Native Windows keeps next-turn delivery: its inbox is a named pipe that requires an auth line, and it is uncaptured. Linux is uncaptured. |
 | Gemini CLI | Package-shipped next-turn certification starts at 0.57.0. Its TUI has no captured external wake or queue interface and `--acp` changes launch ownership, so native delivery is fallback-only; live push and reply routing remain false. |
 | Grok | The Grok 1.0.24 installed-client check observed own CLI arguments after a terminal result, followed by owned work, message, and finish calls. This identity-only path does not certify peer-context injection. Documentation-shaped payloads do not count as real captures. The public leader surface exposed no proven addressed injection into an ordinary TUI session, so native delivery is `awaiting_compatibility_capture`; all capabilities remain false. |
 | Kimi Code | Next-turn and guard evidence was captured on 0.36.1, plus a 60-second heartbeat. Its server/queue APIs do not prove a transparent binding to an independently opened session, so native delivery is fallback-only. |
@@ -93,10 +102,11 @@ demand without a client heartbeat. Retirement is final: neither route may revive
 retired binding, a closed session or an old generation. Delivery lease refresh does
 not renew participant presence.
 
-On darwin-arm64, Codex LocalDaemon, the Claude Code inbox wake and the Antigravity CLI
-relay have captured experimental live delivery. Other adapters retain their separately
-certified next-turn paths or inbox polling. Linux and other uncaptured platforms retain
-the durable inbox; these captures establish no new hook capabilities there.
+Codex LocalDaemon, the Claude Code inbox wake and the Antigravity CLI relay have captured
+experimental live delivery, on darwin-arm64. Those captures set the minimum that applies on
+every platform; on a host they never named, the probe and the per-session handshake decide,
+and a transport that does not answer keeps the durable inbox. Other adapters retain their
+separately certified next-turn paths or inbox polling.
 
 Codex's 120-second delivery lease can refresh on demand for the same live endpoint;
 it does not extend the 24-hour participant presence limit. A TUI exit can leave its
@@ -116,8 +126,8 @@ policy:
 | `all` | every addressed message kind may use live push |
 
 The default is `off`. `acc install --delivery actionable|all` records recipient consent.
-Current activation remains off when the platform, captured minimum or feature probe
-does not qualify; that temporary failure does not erase the requested policy. Each
+Current activation remains off when the captured minimum or the feature probe does not
+qualify; that temporary failure does not erase the requested policy. Each
 session must pass its own generation-bound handshake. Every adapter reads consent from the
 installation record and rereads it at hooks and before offers, so a long-running vendor
 process cannot retain permission through an old binding snapshot.

package/docs/CLI.md

@@ -104,9 +104,12 @@ got. Two sessions of one participant show the same numbers, so read the workspac
 `<n> offered, not retrieved` when that number is above zero. Offered is not read: a
 transport took the bytes, and the model may or may not have looked.
 
-A participant with no open session is left out, unless messages still wait for it. Then its
-latest session stays listed as `offline`, with `endReason` when the client said why the
-session ended, such as `"clear"` for Claude Code's `/clear`. The text line names each one:
+A participant with no open session is left out, unless messages still wait for it: queued,
+or offered by a live transport and not yet shown again, so that its next turn would show
+them. A message the next-turn hook already showed does not wait, since nothing will reach the
+participant for it again. A waiting participant's latest session stays listed as `offline`,
+with that number as `waiting`, and with `endReason` when the client said why the session
+ended, such as `"clear"` for Claude Code's `/clear`. The text line names each one:
 `waiting for a closed session: claude_code-b (cleared, 2)`. `acc status --all` lists every
 session. Default `sync` reads
 events after a 16-digit event cursor (100 by

package/docs/PROTOCOL.md

@@ -316,8 +316,8 @@ The recipient owns `livePolicy` because native push may start a model turn:
 
 Default is `off`. Policy never creates a capability. The router requires one
 current eligible recipient generation, supported client evidence, a verified
-binding and adapter acceptance. The Claude Code inbox wake uses a captured 2.1.282
-minimum on darwin-arm64. Its binding requires the same pid and socket in Claude Code's
+binding and adapter acceptance. The Claude Code inbox wake uses a 2.1.282 minimum,
+captured on darwin-arm64 and applied on every platform. Its binding requires the same pid and socket in Claude Code's
 session registry, and every refresh and wake also requires the same session id. Codex LocalDaemon uses a 0.152.1 minimum, confirmed
 through installed-product captures on 0.152.1 and 0.153.4. Recorded consent and
 exact thread, cwd, process, version and protocol verification govern every Codex session.

package/docs/RELEASING.md

@@ -1,8 +1,8 @@
 # Releasing
 
 Use this procedure to build one auditable npm artifact, verify that exact tarball, and keep
-its evidence tied to the commit that supplied its bytes. The package is currently `0.5.0`;
-the commands derive the version from `package.json` so the filename cannot drift.
+its evidence tied to the commit that supplied its bytes. The commands derive the version
+from `package.json` so the filename cannot drift.
 
 ```mermaid
 graph LR
@@ -118,8 +118,10 @@ work belongs under `Unreleased` and gets a new candidate record.
 ## Capture only capabilities you observed
 
 Run native real-client checks on the exact versions and platforms recorded in
-retained fixtures. Exact-version evidence governs normal-turn and guard behavior.
-The Claude Code inbox wake uses its captured macOS arm64 minimum plus a current probe and
+retained fixtures. A capture records evidence, and it never gates beyond that floor: what it
+proves applies from its version onward and on every platform, and what refuses a client is
+the machine's own probe or handshake, an older client, or a recorded regression.
+The Claude Code inbox wake uses its captured minimum plus a current probe and
 per-session handshake. Its passing capture is a real-client product run of the packed
 candidate, launched with the ordinary command and installed hooks. Codex LocalDaemon
 uses a separate 0.152.1 minimum with installed-product captures on 0.152.1 and

package/docs/TROUBLESHOOTING.md

@@ -240,8 +240,8 @@ local socket permissions as well; a writable state directory alone is insufficie
 ## Gemini does not guard a write
 
 Default and `plan` modes expose no write tool to the model. `auto_edit` exposes edit tools;
-shell availability depends on approval mode. Only Gemini CLI 0.57.0 on `darwin-arm64` has
-package-shipped delivery certification; other versions still use inbox.
+shell availability depends on approval mode. Gemini CLI next-turn delivery is certified from
+0.57.0 onward, on every platform; an older client still uses inbox.
 
 From 0.55 onwards there is a quieter cause with the same symptom: an untrusted folder. The
 client prints `Approval mode overridden to "default" because the current folder is not

package/node_modules/@agents-can-communicate/adapter-antigravity/package.json

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

package/node_modules/@agents-can-communicate/adapter-antigravity/plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "acc",
-  "version": "0.8.0",
+  "version": "0.8.1",
   "description": "Coordinate this Antigravity CLI session with other AI agent sessions working in the same workspace."
 }

package/node_modules/@agents-can-communicate/adapter-antigravity/src/adapter.mjs

@@ -76,9 +76,8 @@ export function createAntigravityAdapter() {
     // no retireNativeSession here: the hook runner retires and re-publishes the
     // binding on every turn, and must not take the relay with it.
     nativeDelivery: {
-      minimumByPlatform: { "darwin-arm64": ANTIGRAVITY_CLI_VERSION },
-      anchors: [{ platform: "darwin-arm64", version: ANTIGRAVITY_CLI_VERSION,
-        protocolContract: PROTOCOL_CONTRACT }],
+      minimum: ANTIGRAVITY_CLI_VERSION,
+      anchors: [{ version: ANTIGRAVITY_CLI_VERSION, protocolContract: PROTOCOL_CONTRACT }],
       knownBad: [], activationKinds: ["native-config"], policySource: "installation-record",
     },
     probeNativeDelivery, planNativeActivation, bindNativeSession, refreshNativeSession,

package/node_modules/@agents-can-communicate/adapter-claude-code/package.json

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

package/node_modules/@agents-can-communicate/adapter-claude-code/src/adapter.mjs

@@ -22,8 +22,9 @@ export const CLAUDE_DELIVERY_FALLBACK = Object.freeze({
  * and a parent/child mapping claimed without observation is the kind of thing
  * that quietly maps every child onto its parent. `startupInjection` and
  * `safePointInjection` were not exercised - only the before-turn path was.
- * Native live delivery is the inbox wake, certified from 2.1.282 on
- * darwin-arm64; reply routing through the transport is not claimed.
+ * Native live delivery is the inbox wake, certified from 2.1.282 (captured on
+ * darwin-arm64, applied on every platform the probe admits); reply routing
+ * through the transport is not claimed.
  */
 export function createClaudeCodeAdapter() {
   return defineAdapter({
@@ -52,8 +53,8 @@ export function createClaudeCodeAdapter() {
     // newer stable client is admitted by the probe and the per-session
     // handshake. The offer is a wake; see src/inbox-delivery.mjs.
     nativeDelivery: {
-      minimumByPlatform: { "darwin-arm64": MIN_VERSION },
-      anchors: [{ platform: "darwin-arm64", version: MIN_VERSION, protocolContract: PROTOCOL_CONTRACT }],
+      minimum: MIN_VERSION,
+      anchors: [{ version: MIN_VERSION, protocolContract: PROTOCOL_CONTRACT }],
       knownBad: [],
       activationKinds: ["native-service"],
       policySource: "installation-record",

package/node_modules/@agents-can-communicate/adapter-claude-code/src/inbox-delivery.mjs

@@ -1,4 +1,5 @@
 import net from "node:net";
+import { compareVersionOrder, versionOrder } from "@agents-can-communicate/adapter-sdk";
 
 import { INBOX_MODES, MIN_VERSION, PROTOCOL_CONTRACT, TRANSPORT } from "./inbox-contract.mjs";
 import { claimWake, newEndpointId, readInboxEndpoint, releaseWake, removeInboxEndpoint,
@@ -26,7 +27,6 @@ const LEASE_MS = 120_000;
 const MESSAGE_ID = /^[A-Za-z0-9_-]{1,200}$/;
 const PROBE_NEEDLE = Buffer.from("messagingSocketPath");
 const PROBE_MAX_BYTES = 256 * 1024 * 1024;
-const STABLE_VERSION = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:\+[0-9A-Za-z.-]+)?$/;
 
 export { INBOX_MODES, MIN_VERSION, PROTOCOL_CONTRACT, TRANSPORT };
 
@@ -37,12 +37,11 @@ export const wakeText = messageId => `ACC: new peer message ${messageId} for thi
   + `acc inbox --message ${messageId}. Answer it through ACC with acc reply --message ${messageId}; `
   + "SendMessage cannot deliver to an ACC participant.";
 
-function compare(left, right) {
-  const a = left.split("+")[0].split(".").map(Number);
-  const b = right.split("+")[0].split(".").map(Number);
-  for (let index = 0; index < 3; index += 1) if (a[index] !== b[index]) return a[index] < b[index] ? -1 : 1;
-  return 0;
-}
+// A version is judged by its release triple: a prerelease of a version above
+// the minimum is not an older client, and the inbox in the executable is what
+// admits it. An unreadable version orders as null.
+const belowMinimum = clientVersion => compareVersionOrder(versionOrder(clientVersion),
+  versionOrder(MIN_VERSION)) < 0;
 
 // The registry field only a build with the inbox writes. Read-only, bounded.
 async function executableHasInbox(realExecutable) {
@@ -92,8 +91,8 @@ function withTimeout(work, ms) {
 }
 
 /**
- * Read-only: a stable version at or above the capture, a platform whose inbox
- * is a Unix socket, and an executable that writes the inbox into its session
+ * Read-only: a version at or above the capture, a platform whose inbox is a
+ * Unix socket, and an executable that writes the inbox into its session
  * registry. Never launches a session. Native Windows serves a named pipe that
  * demands an auth line; nothing there is captured, so it keeps hook delivery.
  */
@@ -105,10 +104,8 @@ export async function probeNativeDelivery({ realExecutable, timeoutMs = 750, pla
   if (typeof realExecutable !== "string" || realExecutable === "") return unsupported("feature_probe_failed");
   const clientVersion = await withTimeout(Promise.resolve(readVersion(realExecutable, timeoutMs)), timeoutMs)
     .catch(() => null);
-  if (clientVersion === null || !STABLE_VERSION.test(clientVersion)) {
-    return unsupported("feature_probe_failed", clientVersion);
-  }
-  if (compare(clientVersion, MIN_VERSION) < 0) return unsupported("below_minimum_version", clientVersion);
+  if (versionOrder(clientVersion) === null) return unsupported("feature_probe_failed", clientVersion);
+  if (belowMinimum(clientVersion)) return unsupported("below_minimum_version", clientVersion);
   const present = await withTimeout(Promise.resolve(hasInbox(realExecutable)), timeoutMs).catch(() => false);
   if (!present) return unsupported("protocol_mismatch", clientVersion);
   return { supported: true, clientVersion, protocolContract: PROTOCOL_CONTRACT,
@@ -145,13 +142,11 @@ export async function bindNativeSession({ event, clientPid, clientVersion, runti
   if (typeof event?.sessionId !== "string" || event.sessionId === "") {
     return closed(clientVersion, "handshake_failed");
   }
-  if (typeof clientVersion !== "string" || !STABLE_VERSION.test(clientVersion)) {
-    return closed(clientVersion, "version_unavailable");
-  }
+  if (versionOrder(clientVersion) === null) return closed(clientVersion, "version_unavailable");
   // The contract refuses it anyway, after this returns. Refusing here keeps an
   // older client - which binds again on every turn - from writing an endpoint
   // record each time.
-  if (compare(clientVersion, MIN_VERSION) < 0) return closed(clientVersion, "below_minimum_version");
+  if (belowMinimum(clientVersion)) return closed(clientVersion, "below_minimum_version");
   const socketPath = env?.CLAUDE_CODE_MESSAGING_SOCKET;
   if (typeof socketPath !== "string" || socketPath === "") {
     return closed(clientVersion, "native_endpoint_unavailable");

package/node_modules/@agents-can-communicate/adapter-claude-code/src/inbox-endpoint.mjs

@@ -2,6 +2,7 @@ import { randomBytes } from "node:crypto";
 import { constants } from "node:fs";
 import { lstat, mkdir, open, readdir, realpath, rename, rm } from "node:fs/promises";
 import path from "node:path";
+import { versionOrder } from "@agents-can-communicate/adapter-sdk";
 
 import { PROTOCOL_CONTRACT } from "./inbox-contract.mjs";
 import { inboxSocketIsSafe } from "./inbox-registry.mjs";
@@ -14,7 +15,6 @@ import { isReception } from "./inbox-settings.mjs";
 const KEYS = ["schemaVersion", "endpointId", "socketPath", "configDir", "clientPid", "sessionId",
   "clientVersion", "protocolContract", "leaseUntil", "reception"];
 const ENDPOINT = /^claude_inbox_[a-f0-9]{32}$/;
-const STABLE = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:\+[0-9A-Za-z.-]+)?$/;
 const MAX_BYTES = 8_192;
 const absolute = value => typeof value === "string" && path.isAbsolute(value) && !value.includes("\0");
 const own = info => typeof process.getuid !== "function" || info.uid === process.getuid();
@@ -29,7 +29,7 @@ function valid(record) {
     && absolute(record.socketPath) && absolute(record.configDir)
     && Number.isInteger(record.clientPid) && record.clientPid > 0
     && typeof record.sessionId === "string" && record.sessionId !== "" && record.sessionId.length <= 200
-    && typeof record.clientVersion === "string" && STABLE.test(record.clientVersion)
+    && typeof record.clientVersion === "string" && versionOrder(record.clientVersion) !== null
     && record.protocolContract === PROTOCOL_CONTRACT
     && typeof record.leaseUntil === "string"
     && /^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d{3}Z$/.test(record.leaseUntil)

package/node_modules/@agents-can-communicate/adapter-codex/package.json

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

package/node_modules/@agents-can-communicate/adapter-codex/src/adapter.mjs

@@ -18,7 +18,7 @@ import { planCodexInstall, detectCodex, installCodexPlugin, preflightCodexUninst
 export { CODEX_QUEUE_MINIMUM };
 export const CODEX_VERSION = "0.147.0";
 export const CODEX_DELIVERY_FALLBACK = Object.freeze({
-  diagnostic: "Codex native delivery requires codex-cli 0.152.1 or newer on darwin-arm64, "
+  diagnostic: "Codex native delivery requires codex-cli 0.152.1 or newer, "
     + "recorded recipient consent and a reachable LocalDaemon session with exact thread, cwd, "
     + "process, version and protocol verification. Embedded or unreachable sessions retain "
     + "durable messages. Message delivery does not start, restart or stop the vendor daemon and adds no "
@@ -61,9 +61,8 @@ export function createCodexAdapter() {
     // Native acceleration is a separate, per-session eligibility decision.
 
     nativeDelivery: {
-      minimumByPlatform: { "darwin-arm64": CODEX_QUEUE_MINIMUM },
-      anchors: [{ platform: "darwin-arm64", version: CODEX_QUEUE_MINIMUM,
-        protocolContract: PROTOCOL_CONTRACT }], knownBad: [],
+      minimum: CODEX_QUEUE_MINIMUM,
+      anchors: [{ version: CODEX_QUEUE_MINIMUM, protocolContract: PROTOCOL_CONTRACT }], knownBad: [],
       activationKinds: ["native-service"], policySource: "installation-record",
     },
     probeNativeDelivery, planNativeActivation, bindNativeSession,

package/node_modules/@agents-can-communicate/adapter-codex/src/app-server-client.mjs

@@ -2,6 +2,8 @@ import os from "node:os";
 import path from "node:path";
 import { realpath, stat } from "node:fs/promises";
 
+import { compareVersionOrder, versionOrder } from "@agents-can-communicate/adapter-sdk";
+
 import { openWebSocketPeer } from "./ws-json-rpc.mjs";
 
 // The Codex App Server queue protocol, captured on codex-cli 0.152.1. Every
@@ -18,7 +20,6 @@ export const MINIMUM_VERSION = "0.152.1";
 export const CODEX_QUEUE_MINIMUM = MINIMUM_VERSION;
 export const QUEUE_MODES = Object.freeze(["livePush", "idleWake", "busyQueue"]);
 const CLIENT_INFO = Object.freeze({ name: "agents-can-communicate", version: "0.2.0" });
-const STABLE_VERSION = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
 const MAX_PAGES = 20;
 const METHOD_NOT_FOUND = -32601;
 const INVALID_REQUEST = -32600;
@@ -27,15 +28,11 @@ export const controlSocketPath = (env = process.env) =>
   path.join(env.CODEX_HOME ?? path.join(os.homedir(), ".codex"),
     "app-server-control", "app-server-control.sock");
 
-export function parseStableVersion(text) {
-  return STABLE_VERSION.test(String(text ?? "")) ? String(text).split(".").map(Number) : null;
-}
-export function compareStableVersions(left, right) {
-  const a = parseStableVersion(left);
-  const b = parseStableVersion(right);
-  for (let index = 0; index < 3; index += 1) if (a[index] !== b[index]) return a[index] < b[index] ? -1 : 1;
-  return 0;
-}
+// A version is judged by its release triple, the same order certification
+// evidence uses: a prerelease daemon above the minimum is admitted by the queue
+// method it answers with, not refused for its suffix. Unreadable orders as null.
+export { versionOrder };
+export const compareVersions = (left, right) => compareVersionOrder(versionOrder(left), versionOrder(right));
 export function serverVersionOf(userAgent) {
   return /^[^\s/]+\/(\d+\.\d+\.\d+(?:-[0-9A-Za-z.]+)?)(?=[\s(]|$)/
     .exec(String(userAgent ?? ""))?.[1] ?? null;
@@ -58,10 +55,10 @@ export async function initializeCodex(peer) {
 
 export async function probeCodexQueue(peer, { threadId, minimum = MINIMUM_VERSION } = {}) {
   const serverVersion = await initializeCodex(peer);
-  if (serverVersion === null || parseStableVersion(serverVersion) === null) {
-    return { supported: false, serverVersion, reasonCode: "prerelease_not_captured" };
+  if (versionOrder(serverVersion) === null) {
+    return { supported: false, serverVersion, reasonCode: "version_unavailable" };
   }
-  if (compareStableVersions(serverVersion, minimum) < 0) {
+  if (compareVersions(serverVersion, minimum) < 0) {
     return { supported: false, serverVersion, reasonCode: "below_minimum_version" };
   }
   try {

package/node_modules/@agents-can-communicate/adapter-codex/src/live-permissions.mjs

@@ -1,6 +1,6 @@
 import path from "node:path";
 import { channelSocketDirectory, tomlString } from "@agents-can-communicate/adapter-sdk";
-import { compareStableVersions, parseStableVersion } from "./app-server-client.mjs";
+import { compareVersions } from "./app-server-client.mjs";
 import { addPermissions, inspectPermissions } from "./permission-ownership.mjs";
 import { scanConfig } from "./toml-scan.mjs";
 
@@ -8,9 +8,9 @@ const PROFILE = "acc-workspace";
 const MINIMUM = "0.153.4";
 const equal = (keys, expected) => JSON.stringify(keys) === JSON.stringify(expected);
 const literal = value => { try { return JSON.parse(value); } catch { return null; } };
-const supported = context => context.platform === "darwin-arm64"
-  && parseStableVersion(context.clientVersion) !== null
-  && compareStableVersions(context.clientVersion, MINIMUM) >= 0;
+// Captured on darwin-arm64 with 0.153.4; the capture's minimum applies on
+// every platform, and a prerelease is judged by its release triple.
+const supported = context => compareVersions(context.clientVersion, MINIMUM) >= 0;
 const hasPermissions = entries => entries.some(entry =>
   ["permissions", "default_permissions", "profile", "profiles"].includes(entry.keys[0]));
 const configured = (source, context) => {
@@ -69,7 +69,7 @@ export function outgoingStatus(source, context) {
       ? "outgoing live delivery: local socket permissions configured for new sessions; active session overrides remain unverified"
       : `outgoing live delivery: sender permissions unverified in ${context.file}; `
         + (reasonCode === "permission_configuration_uncaptured"
-          ? `automatic setup requires Codex ${MINIMUM} or newer on darwin-arm64`
+          ? `automatic setup requires Codex ${MINIMUM} or newer`
           : custom
             ? "custom permission policy was preserved; manually allow ACC state and local sockets "
               + "through the network proxy in the effective workspace profile"