agents-can-communicate 0.8.0 → 0.8.2

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

@@ -1,10 +1,12 @@
 import { lstat, realpath } from "node:fs/promises";
 import path from "node:path";
-import { socketIsReady } from "./native-endpoint.mjs";
+import { readySocketPath, socketIsReady } from "./native-endpoint.mjs";
 import { probeNativeDelivery } from "./native-delivery.mjs";
 import { installCodexStandalone } from "./standalone-install.mjs";
-import { failMaintenance, maintenanceContext, probeMaintenanceCli, probeMaintenanceInstall,
-  readMaintenancePid, runMaintenanceCommand, verifyMaintenanceProcess } from "./maintenance-host.mjs";
+import { refusesConnections } from "./ws-json-rpc.mjs";
+import { approvedProcessIsDead, failMaintenance, maintenanceContext, probeMaintenanceCli,
+  probeMaintenanceInstall, readMaintenancePid, runMaintenanceCommand, verifyMaintenanceProcess }
+  from "./maintenance-host.mjs";
 
 const keys = ["home", "codexHome", "cliPath", "cliVersion", "managedPath", "managedVersion",
   "managedRealPath", "cliIdentity", "managedIdentity", "socketPath", "pidPath", "platform"];
@@ -14,6 +16,7 @@ const own = info => typeof process.getuid !== "function" || info.uid === process
 const sessionNeeded = "Codex service ready; open a new Codex session to establish its delivery binding and review client hooks and permissions";
 const diagnostics = {
   native_endpoint_unavailable: "Prepare the missing Codex service with codex app-server daemon start, then open a new Codex session",
+  service_stopped: "The Codex service stopped and left its files behind; acc install starts it in place with codex app-server daemon start, which replaces them, then open a new Codex session",
   managed_install_missing: "Codex service needs its standalone package; run acc install to download the matching official Codex release and prepare the service",
   managed_install_incomplete: "Codex standalone installation is incomplete; repair it with the official Codex installer, then retry acc install",
   prerequisite_consent_required: "Codex standalone download was not approved. Run acc install --adapter codex --delivery actionable to allow the download and automatic peer requests",
@@ -21,7 +24,6 @@ const diagnostics = {
   prerequisite_integrity_failed: "The Codex installer checksum did not match the reviewed version; no installer was run",
   prerequisite_install_failed: "The official Codex installation did not complete; check connectivity and the selected Codex home, then retry acc install",
   managed_binary_mismatch: "Codex CLI and managed standalone versions differ; repair the vendor installation, then retry acc install",
-  maintenance_platform_unsupported: "Codex service preparation is captured only on darwin-arm64; configure the vendor service manually",
   maintenance_cli_unsupported: "Codex cold service preparation requires codex-cli 0.154.0 or newer with daemon commands; update the vendor installation, then retry acc install",
 };
 function report(state, reasonCode, facts = {}) {
@@ -38,6 +40,20 @@ export function createCodexServiceSetup({ run = runMaintenanceCommand, probe = p
     try { return await fs.lstat(file); }
     catch (error) { if (error.code === "ENOENT") return null; throw error; }
   }
+  // A service that stopped without cleaning up: its pid file names a process
+  // that is gone, and its socket refuses every connection; either may be gone
+  // already. Prepared like an absent one: Codex's own start replaces both
+  // files (measured on 0.155.1), and every identity check follows it.
+  async function serviceStopped(paths) {
+    if (await info(paths.pidPath)) {
+      const recorded = await readMaintenancePid(paths.pidPath).catch(() => null);
+      if (recorded === null || !await approvedProcessIsDead(recorded, paths, run)) return false;
+    }
+    // Absent, or a symlink whose socket is gone (what 0.157.1 leaves after a
+    // reboot cleared /private/tmp), or a socket nothing listens on.
+    const target = await fs.realpath(paths.socketPath).catch(() => null);
+    return target === null || (await socketIsReady(target) && await refusesConnections(target));
+  }
   async function safeDirectories(paths) {
     for (const dir of [paths.codexHome, path.dirname(paths.socketPath), path.dirname(paths.pidPath)]) {
       const stat = await info(dir);
@@ -79,7 +95,7 @@ export function createCodexServiceSetup({ run = runMaintenanceCommand, probe = p
       socketPath: paths.socketPath, pidPath: paths.pidPath, platform: paths.platform, ...installation });
   }
   async function verify(paths, facts) {
-    if (!await socketIsReady(paths.socketPath)) failMaintenance("daemon_socket_unproven");
+    if (!await readySocketPath(paths.socketPath)) failMaintenance("daemon_socket_unproven");
     const version = await run(facts.cliPath, ["app-server", "daemon", "version"], paths.options);
     if (version.status !== 0) failMaintenance("daemon_version_unavailable");
     const observed = JSON.parse(version.stdout);
@@ -103,7 +119,6 @@ export function createCodexServiceSetup({ run = runMaintenanceCommand, probe = p
   async function inspect(context, { strict = false } = {}) {
     try {
       const paths = await contextPaths(context);
-      if (paths.platform !== "darwin-arm64") failMaintenance("maintenance_platform_unsupported");
       if (!strict) {
         const native = await probe({ env: paths.options.env, timeoutMs: 1_500 });
         // Preserve the existing delivery support matrix: a healthy older
@@ -116,6 +131,7 @@ export function createCodexServiceSetup({ run = runMaintenanceCommand, probe = p
       if (!await info(paths.socketPath) && !await info(paths.pidPath)) {
         return report("needed", "native_endpoint_unavailable", facts);
       }
+      if (await serviceStopped(paths)) return report("needed", "service_stopped", facts);
       return await verify(paths, facts);
     } catch (error) {
       const reason = error.reasonCode ?? "service_inspection_failed";
@@ -166,9 +182,10 @@ export function createCodexServiceSetup({ run = runMaintenanceCommand, probe = p
       if (current.state !== "needed") return { ...current, state: "blocked", started };
       const paths = await contextPaths(context);
       if (!same(plan, await installed(paths))) failMaintenance("service_identity_changed");
-      // Last check immediately before the only mutating command. Never delete
-      // stale metadata or stop/restart a process on this path.
-      if (await info(paths.socketPath) || await info(paths.pidPath)) {
+      // Last check immediately before the only mutating command. ACC deletes no
+      // metadata and never stops or restarts a process on this path; a service
+      // whose files are all that is left of it is started over them.
+      if ((await info(paths.socketPath) || await info(paths.pidPath)) && !await serviceStopped(paths)) {
         return { ...await verify(paths, current), started };
       }
       started = true;

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

@@ -63,6 +63,18 @@ export function acceptKey(key) {
   return createHash("sha1").update(`${key}${GUID}`).digest("base64");
 }
 
+/** True only when a connect to the socket is refused: a file with nobody
+ * listening. Accepting, timing out, or any other error is not proof of that. */
+export function refusesConnections(socketPath, { timeoutMs = 1_000 } = {}) {
+  return new Promise(resolve => {
+    const socket = net.createConnection({ path: socketPath });
+    const settle = refused => { clearTimeout(timer); socket.destroy(); resolve(refused); };
+    const timer = setTimeout(() => settle(false), timeoutMs);
+    socket.once("connect", () => settle(false));
+    socket.once("error", error => settle(error?.code === "ECONNREFUSED"));
+  });
+}
+
 export function openWebSocketPeer({ socketPath, timeoutMs, path = "/", host = "localhost",
   retainNotifications = true }) {
   const notifications = [];

package/node_modules/@agents-can-communicate/adapter-gemini-cli/extension/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-can-communicate",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "Coordinate this Gemini CLI session with other AI agent sessions working in the same workspace.",
   "contextFileName": "skills/acc/SKILL.md"
 }

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

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

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

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

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

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

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

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

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

@@ -129,6 +129,13 @@ export function defineAdapter(manifest) {
       usage(`optional native method ${method} must be a function`, { id: manifest.id, method });
     }
   }
+  // `inboundSockets(context)` names the Unix socket paths - directories or
+  // sockets - a sender connects to when this adapter's sessions receive live
+  // delivery. A sandboxed sender's installer allows exactly these, so a value
+  // that is not a function would silently read as "nothing to allow".
+  if (manifest.inboundSockets !== undefined && typeof manifest.inboundSockets !== "function") {
+    usage("optional inboundSockets must be a function", { id: manifest.id });
+  }
   if (manifest.nativeDelivery !== undefined) {
     const client = manifest.client.certificationName ?? manifest.client.command;
     native.nativeDelivery = validateNativeDeliveryContract(manifest.nativeDelivery,

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

@@ -25,13 +25,13 @@ const TRIPLE = /^(\d+)\.(\d+)\.(\d+)(?:[-+][0-9A-Za-z.-]+)?$/;
  * version ACC has already observed is not an older client. Anything unreadable
  * - a probe that failed, "unknown", a vendor string - returns null.
  */
-function versionOrder(text) {
+export function versionOrder(text) {
   const match = typeof text === "string" && text.toLowerCase() !== "unknown"
     ? TRIPLE.exec(text) : null;
   return match === null ? null : [Number(match[1]), Number(match[2]), Number(match[3])];
 }
 
-function compareVersionOrder(left, right) {
+export function compareVersionOrder(left, right) {
   if (left === null || right === null) return left === right ? 0 : left === null ? -1 : 1;
   for (let index = 0; index < 3; index += 1) {
     if (left[index] !== right[index]) return left[index] < right[index] ? -1 : 1;

package/node_modules/@agents-can-communicate/adapter-sdk/src/hook-shim.mjs

@@ -84,6 +84,15 @@ const PLACEHOLDER = "{{ACC}}";
 // shell's to interpret.
 const quote = value => `"${String(value).replace(/(["\\$`])/g, "\\$1")}"`;
 
+/**
+ * Whether a path is one shell word exactly as written: absolute, and made only
+ * of the POSIX portable filename characters and slashes. Nothing in it is
+ * expanded, split or quoted by a shell, so the unquoted text and the word a
+ * shell runs are the same string.
+ */
+export const isShellWord = value => typeof value === "string"
+  && /^\/[A-Za-z0-9._/-]*$/.test(value);
+
 /**
  * Write the small shim a client's hook command points at.
  *
@@ -231,13 +240,18 @@ export const defaultCli = () => ownBinary("acc.mjs");
  * JSON, worked out the schema, and wrote records and events by hand - inventing
  * an event type, a harness name, and its own generation tokens. So the command
  * is pinned here for the same reason it is pinned in the shim.
+ *
+ * `bareWhenSafe` names the shim without quotes when it is one shell word. A
+ * client that matches allow rules against the command's first word needs it:
+ * Antigravity CLI 1.2.12 never matched a command whose program word was quoted,
+ * whatever rule was loaded (issue #214). A path that needs quotes keeps them.
  */
-export async function bakeSkillCommand({ root, cliShim }) {
+export async function bakeSkillCommand({ root, cliShim, bareWhenSafe = false }) {
   if (typeof cliShim !== "string" || cliShim === "") {
     throw new AccError(EXIT.DATA, "refusing to bake an empty skill command", { cliShim });
   }
   // A managed data home is "Application Support"; an unquoted path splits.
-  const command = quote(cliShim);
+  const command = bareWhenSafe && isShellWord(cliShim) ? cliShim : quote(cliShim);
   const baked = [];
   const walk = async directory => {
     for (const entry of await readdir(directory, { withFileTypes: true })) {

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

@@ -1,14 +1,15 @@
 // Capability contract, context projection, config ownership, and the binding
 // that survives between two ephemeral hook processes.
 export { CAPABILITY_SHAPE, assertCapabilities, defineAdapter } from "./capabilities.mjs";
-export { capabilityEvidence, effectiveCapabilities, validateCertification }
+export { capabilityEvidence, compareVersionOrder, effectiveCapabilities, validateCertification,
+  versionOrder }
   from "./certification.mjs";
-export { NATIVE_ACTIVATION_KINDS, NATIVE_BINDING_MODES, NATIVE_PLATFORMS, NATIVE_REASON_CODES,
+export { NATIVE_ACTIVATION_KINDS, NATIVE_BINDING_MODES, NATIVE_REASON_CODES,
   compareStableVersions, evaluateNativeEligibility, evaluateVersionContract, parseStableVersion,
   validateNativeActivationPlan, validateNativeDeliveryContract, validateNativeHandshake }
   from "./native-delivery.mjs";
 export { EVENT_KINDS, NORMALIZED_EVENT_KEYS, normalizedEvent } from "./events.mjs";
-export { assertRunner, bakeSkillCommand, defaultAntigravityRelay, defaultCli,
+export { assertRunner, bakeSkillCommand, defaultAntigravityRelay, defaultCli, isShellWord,
   defaultRunner, removeInstalledTree, runnerExists, writeCliShim, writeHookShim }
   from "./hook-shim.mjs";
 export { BEGIN, END, removeTomlBlock, renderBlock, stripBlock, tomlString, writeTomlBlock }

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

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

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

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

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

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

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

@@ -12,7 +12,7 @@ export { describeNative } from "./native-delivery-status.mjs";
 import { nativeSessionLines, updateNativeSessions } from "./native-session-diagnostics.mjs";
 import { ALL_ADAPTERS, clientContext, probeTimeout } from "./install-command.mjs";
 import { decisionOf } from "./install-delivery-consent.mjs";
-import { describePresence } from "./main.mjs";
+import { describePresence, presenceBreakdown } from "./main.mjs";
 import { platformPaths } from "./platform-paths.mjs";
 import { noticeUpdate } from "./update-check.mjs";
 import { managedUpdateDiagnostic } from "./managed-runtime/diagnostics.mjs";
@@ -116,7 +116,7 @@ export async function diagnoseAdapters({ options, runtime, detect = detectInstal
     env: runtime?.env ?? {} });
   // The same environment install reads, so detection probes the same client.
   const clients = clientContext(home, path.join(dataHome, "acc"),
-    { env: runtime?.env ?? {} });
+    { env: runtime?.env ?? {}, platform: runtime?.platform });
   const adapters = ALL_ADAPTERS();
   const detected = await detect({ adapters, context: clients,
     probeTimeoutMs: probeTimeout(runtime?.env) });
@@ -192,8 +192,12 @@ export async function runDoctor({ options, context, runtime }) {
   // "unreadable protocol.json" and a person's first `acc doctor` in a new
   // project would answer that their store is broken.
   const started = await stat(path.join(root, "protocol.json")).then(() => true, () => false);
+  // Shaped like the storage report, so a reader of one finds every field of
+  // the other: without `trimmedThrough` the summary said "history from
+  // undefined" on every first doctor in a new project.
   const report = !started
-    ? { healthy: true, blocked: [], corrupt: [], repaired: [] }
+    ? { healthy: true, blocked: [], corrupt: [], repaired: [], swept: 0, staged: 0, partials: 0,
+      retired: 0, trimmedThrough: null }
     : options.repair === true
       ? await repairFilesystemStore({ root, clock })
       : await diagnoseFilesystemStore({ root });
@@ -276,7 +280,8 @@ export async function runDoctor({ options, context, runtime }) {
     report.trimmedThrough === null ? null : `history from ${report.trimmedThrough}`,
   ].filter(Boolean);
   const staging = held.length === 0 ? "" : ` (${held.join(", ")})`;
-  const text = [`store healthy${staging}; ${describePresence(status.counts)}; `
+  const text = [`store healthy${staging}; `
+    + `${describePresence(status.counts, presenceBreakdown(status.participants, ALL_ADAPTERS()))}; `
     + `protection ${status.protection}; ${installed} of ${adapters.length} adapter(s) installed`,
   ...adapters.filter(adapter => (adapter.present || adapter.installed)
     && adapter.nativeDelivery.reasonCode === "native_delivery_unsupported"

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

@@ -7,7 +7,7 @@ import { createCodexAdapter } from "@agents-can-communicate/adapter-codex";
 import { createGeminiCliAdapter } from "@agents-can-communicate/adapter-gemini-cli";
 import { createGrokAdapter } from "@agents-can-communicate/adapter-grok";
 import { createKimiAdapter } from "@agents-can-communicate/adapter-kimi";
-import { applyPlan, detectInstallation, loadOwnership, planInstallation }
+import { applyPlan, detectInstallation, loadOwnership, planInstallation, receiverSockets }
   from "@agents-can-communicate/installer";
 import { AccError, EXIT } from "@agents-can-communicate/protocol";
 
@@ -28,7 +28,7 @@ export { decideDelivery } from "./install-delivery-consent.mjs";
 // pointed at the home itself writes beside them rather than inside them. That
 // install reports success and the client never reads a byte of it.
 export const clientContext = (home, stateRoot,
-  { env = {}, dataHome, cwd = process.cwd() } = {}) => ({
+  { env = {}, dataHome, cwd = process.cwd(), platform } = {}) => withReceivers({
   home,
   ...(dataHome === undefined ? {} : { dataHome }),
   configDir: path.join(home, ".claude"),
@@ -59,7 +59,14 @@ export const clientContext = (home, stateRoot,
   // roster and record nothing, every write failing with EPERM on the writer
   // lock. Measured with `codex exec`, which is how an agent actually runs.
   stateRoot,
-});
+}, platform);
+
+// Every socket ACC can deliver to, as each receiving adapter declares it, for
+// the one sender that sandboxes its shell: the Codex permission profile is
+// written and diagnosed from this list, so it covers Claude Code's inbox even
+// when an install names Codex alone (issue #213).
+const withReceivers = (context, platform) => ({ ...context,
+  receiverSockets: receiverSockets(ALL_ADAPTERS(), { ...context, platform }) });
 
 export const ALL_ADAPTERS = () => [createAntigravityAdapter(), createClaudeCodeAdapter(),
   createCodexAdapter(), createGeminiCliAdapter(), createGrokAdapter(), createKimiAdapter()];
@@ -222,7 +229,7 @@ export async function runInstallCommand({ options, runtime, action = "install" }
   const { data: dataHome } = platformPaths({ platform: runtime.platform,
     env: runtime.env ?? {} });
   const context = clientContext(home, path.join(dataHome, "acc"),
-    { env: runtime.env ?? {}, dataHome });
+    { env: runtime.env ?? {}, dataHome, platform: runtime.platform });
 
   const detected = await detectInstallation({ adapters, context,
     probeTimeoutMs: probeTimeout(runtime.env) });