agents-can-communicate 0.8.0 → 0.8.2

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

@@ -0,0 +1,41 @@
+import path from "node:path";
+
+// Where Claude Code binds a session's inbox socket, read from the 2.1.283
+// binary (2026-09-27):
+//
+//   `${XDG_RUNTIME_DIR || CLAUDE_CODE_TMPDIR || "/tmp"}/cc-socks/<pid>.sock`
+//
+// and, when that path is longer than 103 bytes, `/tmp/cc-socks-<uid>/<pid>.sock`
+// (`$PREFIX/tmp` when TERMUX_VERSION is set). Claude Code's own list of default
+// socket directories adds `/run/user/<uid>/cc-socks` on Linux. Observed on
+// macOS: `/tmp/cc-socks/<pid>.sock`.
+//
+// A sender in a sandbox - a Codex shell running `acc reply` - has to be allowed
+// to connect here, or every live offer to a Claude Code session fails with
+// EPERM and waits for the recipient's next turn. The grant is a directory; the
+// adapter still checks Claude Code's session registry before every write, so a
+// wider grant cannot wake a reused pid.
+//
+// A relative override is resolved against the Claude Code process's own working
+// directory, which no installer can know, so it is left out. Native Windows
+// serves the inbox on a named pipe, which no Unix socket grant covers.
+
+const hostOf = platform => String(platform ?? process.platform).split("-")[0];
+const set = value => typeof value === "string" && value !== "";
+
+export function inboxSocketDirectories({ env = {}, platform, uid } = {}) {
+  const host = hostOf(platform);
+  if (host === "win32") return [];
+  const user = Number.isInteger(uid) ? uid : (process.getuid?.() ?? 0);
+  // Claude Code's `||`: an empty value falls through to the next one.
+  const root = [env.XDG_RUNTIME_DIR, env.CLAUDE_CODE_TMPDIR].find(set) ?? "/tmp";
+  const fallbackRoot = set(env.TERMUX_VERSION) && set(env.PREFIX)
+    ? path.join(env.PREFIX, "tmp") : "/tmp";
+  const directories = [
+    path.join(root, "cc-socks"),
+    "/tmp/cc-socks",
+    ...(host === "linux" ? [`/run/user/${user}/cc-socks`] : []),
+    path.join(fallbackRoot, `cc-socks-${user}`),
+  ];
+  return [...new Set(directories.filter(directory => path.isAbsolute(directory)))];
+}

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.2",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -11,6 +11,7 @@ import { allowOutcome, denyOutcome, injectOutcome, normalizeCodexHook }
   from "./hooks.mjs";
 import { planCodexInstall, detectCodex, installCodexPlugin, preflightCodexUninstall,
   uninstallCodexPlugin } from "./install.mjs";
+import { controlSocket } from "./live-permissions.mjs";
 // Public native wiring is enabled only with installed-product capture evidence.
 
 // Re-exported so existing importers of CODEX_QUEUE_MINIMUM keep resolving; the
@@ -18,7 +19,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,13 +62,14 @@ 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,
     refreshNativeSession, retireNativeSession, offerMessage,
+    // A Codex sender reaches another Codex session through its control socket.
+    inboundSockets: context => [controlSocket(context)],
     ...createCodexMaintenance(),
     ...createCodexServiceSetup(),
     startSession: async () => ({ ok: true, changes: [], diagnostics: [] }),

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/install.mjs

@@ -161,7 +161,7 @@ const sandboxReview = (config, file, stateRoot) =>
 
 export async function installCodexPlugin({ home, agentsHome = home,
   codexHome = path.join(home, ".codex"), dataHome, stateRoot, runner, node, cli, keepPreviousVersion = null,
-  requestedLivePolicy, livePolicy, clientVersion, platform }) {
+  requestedLivePolicy, livePolicy, clientVersion, platform, receiverSockets }) {
   // Read before writing, so a manifest that will not parse is found before a
   // plugin tree is laid down that nothing will then be able to remove.
   const existing = await readJson(marketplacePath(agentsHome), { name: MARKETPLACE,
@@ -182,7 +182,7 @@ export async function installCodexPlugin({ home, agentsHome = home,
       + "remove it and install again", { config });
   }
   const permissions = prepareLivePermissions(foreign.source, { home, codexHome, stateRoot,
-    file: config, requestedLivePolicy, livePolicy, clientVersion, platform });
+    file: config, requestedLivePolicy, livePolicy, clientVersion, platform, receiverSockets });
   const theirSandbox = permissions.skipLegacy || inspectConfig(permissions.source, config).sandbox;
   const permissionActions = permissions.status?.state === "unverified" ? [permissions.status.diagnostic] : [];
 
@@ -338,7 +338,8 @@ export async function uninstallCodexPlugin({ home, agentsHome = home,
 }
 
 export async function detectCodex({ home, agentsHome = home,
-  codexHome = path.join(home, ".codex"), stateRoot, clientVersion, platform, nativeDelivery }) {
+  codexHome = path.join(home, ".codex"), stateRoot, clientVersion, platform, nativeDelivery,
+  receiverSockets }) {
   const marketplace = await readJson(marketplacePath(agentsHome), null);
   const published = (marketplace?.plugins ?? []).some(entry => entry.name === PLUGIN_NAME);
   const config = await readFile(configPath(codexHome), "utf8").catch(() => "");
@@ -347,7 +348,7 @@ export async function detectCodex({ home, agentsHome = home,
   const cached = await stat(cachePath(codexHome))
     .then(() => true).catch(() => false);
   const outgoingDelivery = outgoingStatus(config, { home, codexHome, stateRoot,
-    file: configPath(codexHome), clientVersion, platform });
+    file: configPath(codexHome), clientVersion, platform, receiverSockets });
   // Saved trust is not readiness. Codex compares every current definition's
   // hash and can disable a trusted hook. Even a commented or stale single record
   // previously suppressed this check. Leave verification to Codex's /hooks;

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

@@ -1,6 +1,7 @@
+import { realpathSync } from "node:fs";
 import path from "node:path";
-import { channelSocketDirectory, tomlString } from "@agents-can-communicate/adapter-sdk";
-import { compareStableVersions, parseStableVersion } from "./app-server-client.mjs";
+import { tomlString } from "@agents-can-communicate/adapter-sdk";
+import { compareVersions } from "./app-server-client.mjs";
 import { addPermissions, inspectPermissions } from "./permission-ownership.mjs";
 import { scanConfig } from "./toml-scan.mjs";
 
@@ -8,9 +9,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) => {
@@ -23,8 +24,12 @@ const configured = (source, context) => {
     && value(["features", "network_proxy"]) === "true"
     && value(["permissions", profile, "network", "enabled"]) === "true"
     && literal(value(["permissions", profile, "filesystem", context.stateRoot])) === "write"
-    && sockets(context).every(socket => literal(value(["permissions", profile, "network", "unix_sockets", socket])) === "allow");
+    && missingSockets(entries, profile, context).length === 0;
 };
+// The grants a profile lacks for the sockets ACC delivers to.
+const missingSockets = (entries, profile, context) => sockets(context).filter(socket =>
+  literal(entries.find(entry => !entry.header
+    && equal(entry.keys, ["permissions", profile, "network", "unix_sockets", socket]))?.value) !== "allow");
 
 const hasCustomPolicy = (source, context) => {
   const ownership = inspectPermissions(source);
@@ -48,10 +53,37 @@ const hasCustomPolicy = (source, context) => {
     || proxies.length > 1 || proxies.some(entry => entry.header || !["true", "false"].includes(entry.value));
 };
 
-// Match the channel's per-user temporary directory and Codex's actual home.
-// Grants cover only ACC's local channel namespace, never arbitrary Unix sockets.
-const sockets = context => [channelSocketDirectory(),
-  path.join(context.codexHome ?? path.join(context.home, ".codex"), "app-server-control", "app-server-control.sock")];
+// Where this adapter's own sessions receive: the app-server control socket in
+// Codex's actual home.
+export const controlSocket = context => path.join(context.codexHome ?? path.join(context.home, ".codex"),
+  "app-server-control", "app-server-control.sock");
+
+// Codex 0.157.1 on macOS, measured with `codex sandbox -P` (2026-09-27): a
+// granted path that exists when Codex builds the sandbox policy is compared in
+// its resolved form, and one that does not is kept as written, while Seatbelt
+// checks the path the kernel resolved. A `/tmp/cc-socks-501` grant made before
+// that directory existed never matched `/private/tmp/cc-socks-501/<pid>.sock`;
+// `/private/tmp/cc-socks-501` did, both before and after. So the existing
+// parent is resolved the way the kernel will, and the last component is kept as
+// spelled: a socket that is a link - Codex's own control socket - must keep
+// naming the link, because its target changes with every daemon.
+export function grantPath(target, realpath = realpathSync.native) {
+  const tail = [path.basename(target)];
+  for (let parent = path.dirname(target); ; parent = path.dirname(parent)) {
+    try {
+      return path.join(realpath(parent), ...tail);
+    } catch {
+      if (parent === path.dirname(parent)) return target;
+      tail.unshift(path.basename(parent));
+    }
+  }
+}
+
+// Every socket ACC delivers to - Codex's own and each receiving adapter's
+// declaration, composed by the installer as `receiverSockets` - and nothing
+// else: grants cover ACC's local receivers, never arbitrary Unix sockets.
+const sockets = context => [...new Set([controlSocket(context), ...(context.receiverSockets ?? [])]
+  .map(socket => grantPath(socket, context.realpath)))].sort();
 
 export function outgoingStatus(source, context) {
   const state = inspectPermissions(source).state;
@@ -62,19 +94,34 @@ export function outgoingStatus(source, context) {
       : ready ? null : "sender_permissions_unverified";
   return { state: reasonCode === null ? "configured" : "unverified", reasonCode,
     setup: supported(context)
-      ? "Codex outgoing setup: default workspace settings gain ACC state write access and an ACC local socket allowlist "
-        + "through the network proxy (external network stays denied); custom policies are preserved. Start a new session after installation."
+      ? "Codex outgoing setup: default workspace settings gain ACC state write access and an allowlist of the "
+        + "local sockets ACC delivers to - ACC's own channel, the Codex control socket and other clients' session "
+        + "inboxes - through the network proxy (external network stays denied); custom policies are preserved. "
+        + "Start a new session after installation."
       : null,
     diagnostic: reasonCode === null
       ? "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"
-            : "ACC outgoing grants are absent; run acc install --adapter codex --delivery actionable, "
-              + "then start a new session") };
+            : state === "owned"
+              ? `${incomplete(source, context)}; run acc install --adapter codex, then start a new session`
+              : "ACC outgoing grants are absent; run acc install --adapter codex --delivery actionable, "
+                + "then start a new session") };
+}
+
+// An owned profile ACC wrote for fewer receivers - 0.8.1 predates the Claude
+// Code inbox grant - or for another state root. Reinstalling rewrites it.
+function incomplete(source, context) {
+  const entries = scanConfig(source);
+  const profile = literal(entries.find(entry => !entry.header && equal(entry.keys, ["default_permissions"]))?.value);
+  const missing = typeof profile === "string" ? missingSockets(entries, profile, context) : [];
+  return missing.length > 0
+    ? `ACC outgoing grants do not cover every socket ACC delivers to; missing ${missing.join(", ")}`
+    : "ACC outgoing grants are out of date";
 }
 
 export function prepareLivePermissions(source, context) {
@@ -85,10 +132,15 @@ export function prepareLivePermissions(source, context) {
   // Once ACC owns a valid outgoing profile, turning incoming requests off must
   // not revoke the already approved ability to use ACC from the sandbox. A
   // fresh off install still creates no grants because it has no owned unit.
-  if (!requested && owned.state === "owned") {
+  // An owned unit written for fewer receivers is brought up to date even so:
+  // the approval was for ACC's local sockets, and without this `acc install`
+  // under a recorded off could never repair a profile an older ACC wrote.
+  const stale = owned.state === "owned" && supported(context) && Boolean(context.stateRoot)
+    && !configured(source, context) && !hasCustomPolicy(owned.source, context);
+  if (!requested && owned.state === "owned" && !stale) {
     return { source, skipLegacy: true, status: outgoingStatus(source, context) };
   }
-  if (!requested) return { source: owned.source, skipLegacy: hasPermissions(scanConfig(owned.source)) };
+  if (!requested && !stale) return { source: owned.source, skipLegacy: hasPermissions(scanConfig(owned.source)) };
   if (!supported(context) || !context.stateRoot) {
     return { source, skipLegacy: hasPermissions(scanConfig(source)), status: outgoingStatus(source, context) };
   }

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

@@ -3,7 +3,7 @@ import { constants } from "node:fs";
 import { access, lstat, open, realpath } from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
-import { compareStableVersions, parseStableVersion } from "./app-server-client.mjs";
+import { compareVersions, versionOrder } from "./app-server-client.mjs";
 
 export const MINIMUM_MAINTENANCE_CLI = "0.154.0";
 export const absolute = value => typeof value === "string" && path.isAbsolute(value)
@@ -15,6 +15,20 @@ export const startTimeValid = value => typeof value === "string"
 export const managedExecutablePaths = codexHome => ["bin/codex", "codex"].map(name =>
   path.join(codexHome, "packages/standalone/current", name));
 
+// Where lsof lives: /usr/sbin on macOS, /usr/bin on Linux. A fixed list of
+// absolute paths, never PATH, so a directory an operator can write to cannot
+// supply the tool that proves socket ownership. The first executable wins;
+// none means the socket cannot be proven and verification fails closed.
+export const LSOF_CANDIDATES = Object.freeze(["/usr/sbin/lsof", "/usr/bin/lsof"]);
+
+export async function resolveLsof({ access: check = access } = {}) {
+  for (const candidate of LSOF_CANDIDATES) {
+    try { await check(candidate, constants.X_OK); return candidate; }
+    catch { /* the next candidate may be the one this host has */ }
+  }
+  return null;
+}
+
 export function runMaintenanceCommand(command, args, options) {
   return new Promise(resolve => execFile(command, args,
     { timeout: 20_000, ...options, maxBuffer: 131_072, windowsHide: true },
@@ -71,12 +85,12 @@ async function resolveCli(pathEnv) {
 }
 
 const cliVersion = response => response.status === 0
-  ? /^codex-cli (\d+\.\d+\.\d+)\s*$/.exec(response.stdout)?.[1] ?? null : null;
+  ? /^codex-cli (\d+\.\d+\.\d+(?:-[0-9A-Za-z.]+)?)\s*$/.exec(response.stdout)?.[1] ?? null : null;
 
 export async function probeMaintenanceCli(paths, run) {
   const cliPath = await resolveCli(paths.options.env.PATH);
   const version = cliVersion(await run(cliPath, ["--version"], paths.options));
-  if (!parseStableVersion(version) || compareStableVersions(version, MINIMUM_MAINTENANCE_CLI) < 0) {
+  if (!versionOrder(version) || compareVersions(version, MINIMUM_MAINTENANCE_CLI) < 0) {
     failMaintenance("maintenance_cli_unsupported");
   }
   const help = await run(cliPath, ["app-server", "daemon", "--help"], paths.options);
@@ -117,17 +131,39 @@ export async function observeMaintenanceProcess(pid, paths, run) {
   return { state: "alive", processStartTime: match[1], command: match[2] };
 }
 
-export async function verifyMaintenanceProcess(snapshot, paths, run) {
+/** Whether `lsof -Fn` output lists a socket at one of these paths. macOS prints
+ * the path alone; Linux appends the socket type (`/path type=STREAM`, measured
+ * on the ubuntu CI job), and a connected peer may carry more after it. The name
+ * is the text before the first ` type=`, compared whole. */
+export function socketListedIn(stdout, socketPaths) {
+  const names = new Set(typeof socketPaths === "string" ? [socketPaths] : socketPaths);
+  return stdout.split("\n").some(line => line.startsWith("n")
+    && names.has(line.slice(1).split(" type=")[0]));
+}
+
+// The daemon's command line as measured: 0.154.0 ran `<current path> app-server
+// --listen unix://`; 0.157.1 runs the resolved releases path with
+// `--managed-daemon` appended. The executable must live in the standalone tree
+// and be the managed binary itself, however the tree names it.
+const DAEMON_COMMAND = /^(\/.+?) app-server --listen unix:\/\/(?: --managed-daemon)?$/;
+
+export async function verifyMaintenanceProcess(snapshot, paths, run, { lsof = resolveLsof } = {}) {
   const process = await observeMaintenanceProcess(snapshot.pid, paths, run);
-  const suffix = " app-server --listen unix://";
-  const executable = process.command?.endsWith(suffix) ? process.command.slice(0, -suffix.length) : null;
+  const executable = DAEMON_COMMAND.exec(process.command ?? "")?.[1] ?? null;
+  const standalone = path.join(paths.codexHome, "packages", "standalone") + path.sep;
   if (process.state !== "alive" || process.processStartTime !== snapshot.processStartTime
-    || !managedExecutablePaths(paths.codexHome).includes(executable)
-    || await realpath(executable) !== await realpath(paths.managedPath)) {
+    || executable === null || !executable.startsWith(standalone)
+    || await realpath(executable).catch(() => null) !== await realpath(paths.managedPath)) {
     failMaintenance("daemon_identity_unavailable");
   }
-  const sockets = await run("/usr/sbin/lsof", ["-n", "-a", "-p", String(snapshot.pid), "-U", "-Fn"], paths.options);
-  if (sockets.status !== 0 || !sockets.stdout.split("\n").includes(`n${paths.socketPath}`)) {
+  // 0.157.1 lists the socket by the path it listens on, not by the symlink it
+  // reports; either names the same socket.
+  const listening = [paths.socketPath, await realpath(paths.socketPath).catch(() => null)]
+    .filter(value => value !== null);
+  const lsofPath = await lsof();
+  if (lsofPath === null) failMaintenance("daemon_socket_unproven");
+  const sockets = await run(lsofPath, ["-n", "-a", "-p", String(snapshot.pid), "-U", "-Fn"], paths.options);
+  if (sockets.status !== 0 || !socketListedIn(sockets.stdout, listening)) {
     failMaintenance("daemon_socket_unproven");
   }
 }

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

@@ -1,6 +1,6 @@
 import path from "node:path";
-import { openCodexAppServer, parseStableVersion } from "./app-server-client.mjs";
-import { socketIsReady } from "./native-endpoint.mjs";
+import { openCodexAppServer, versionOrder } from "./app-server-client.mjs";
+import { readySocketPath } from "./native-endpoint.mjs";
 import { absolute, approvedProcessIsDead, failMaintenance, maintenanceContext,
   managedExecutablePaths, metadataExists, probeMaintenanceInstall, readMaintenancePid, runMaintenanceCommand,
   startTimeValid, verifyMaintenanceProcess } from "./maintenance-host.mjs";
@@ -16,7 +16,7 @@ function validApproval(value) {
   return value?.serviceId === "codex-app-server" && ["ready", "busy"].includes(value.state)
     && Number.isSafeInteger(value.pid) && value.pid > 1 && startTimeValid(value.processStartTime)
     && ["codexHome", "cliPath", "managedPath", "socketPath"].every(key => absolute(value[key]))
-    && ["cliVersion", "serverVersion", "managedVersion"].every(key => parseStableVersion(value[key]))
+    && ["cliVersion", "serverVersion", "managedVersion"].every(key => versionOrder(value[key]))
     && value.managedVersion === value.cliVersion
     && managedExecutablePaths(value.codexHome).includes(value.managedPath)
     && value.socketPath === path.join(value.codexHome, "app-server-control/app-server-control.sock");
@@ -36,8 +36,7 @@ export function createCodexMaintenance({ run = runMaintenanceCommand, open = ope
       const paths = await maintenanceContext(context);
       Object.assign(snapshot, { codexHome: paths.codexHome, socketPath: paths.socketPath, managedPath: paths.managedPath });
       if (!await metadataExists(paths.socketPath) && !await metadataExists(paths.pidPath)) return null;
-      if (paths.platform !== "darwin-arm64") failMaintenance("maintenance_platform_unsupported");
-      if (!await socketIsReady(paths.socketPath)) failMaintenance("daemon_socket_unproven");
+      if (!await readySocketPath(paths.socketPath)) failMaintenance("daemon_socket_unproven");
       Object.assign(snapshot, await probeMaintenanceInstall(paths, run));
       const version = await run(snapshot.cliPath, ["app-server", "daemon", "version"], paths.options);
       if (version.status !== 0) failMaintenance("daemon_version_unavailable");
@@ -45,7 +44,7 @@ export function createCodexMaintenance({ run = runMaintenanceCommand, open = ope
       if (observed.status !== "running" || observed.backend !== "pid") failMaintenance("maintenance_backend_unsupported");
       if (observed.managedCodexPath !== snapshot.managedPath || observed.socketPath !== snapshot.socketPath
         || observed.cliVersion !== snapshot.cliVersion || observed.managedCodexVersion !== snapshot.managedVersion
-        || !parseStableVersion(observed.appServerVersion)) failMaintenance("daemon_identity_unavailable");
+        || !versionOrder(observed.appServerVersion)) failMaintenance("daemon_identity_unavailable");
       snapshot.serverVersion = observed.appServerVersion;
       Object.assign(snapshot, await readMaintenancePid(paths.pidPath));
       await verifyMaintenanceProcess(snapshot, paths, run);
@@ -83,7 +82,6 @@ export function createCodexMaintenance({ run = runMaintenanceCommand, open = ope
     try {
       const pinned = { ...context, env: { ...(context?.env ?? process.env), CODEX_HOME: expected.codexHome } };
       const paths = await maintenanceContext(pinned);
-      if (paths.platform !== "darwin-arm64") return refused("maintenance_platform_unsupported");
       const install = { ...paths, ...await probeMaintenanceInstall(paths, run) };
       if (!sameFields(expected, install, installationKeys)) return refused("service_identity_changed");
       const existing = await inspectMaintenance(pinned);

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

@@ -1,11 +1,10 @@
-import { realpath } from "node:fs/promises";
 import { decisionBody } from "@agents-can-communicate/adapter-sdk";
 
 import { CODEX_QUEUE_MINIMUM, MINIMUM_VERSION, PROTOCOL_CONTRACT, QUEUE_MODES,
-  addCodexQueueMessage, canonicalCwd, compareStableVersions, controlSocketPath,
-  locateCodexThread, openCodexAppServer, parseStableVersion, probeCodexQueue,
-  safeReason, serverVersionOf } from "./app-server-client.mjs";
-import { newEndpointId, readNativeEndpoint, removeNativeEndpoint, socketIsReady,
+  addCodexQueueMessage, canonicalCwd, compareVersions, controlSocketPath,
+  locateCodexThread, openCodexAppServer, probeCodexQueue, safeReason, serverVersionOf,
+  versionOrder } from "./app-server-client.mjs";
+import { newEndpointId, readNativeEndpoint, readySocketPath, removeNativeEndpoint, socketIsReady,
   writeNativeEndpoint } from "./native-endpoint.mjs";
 
 // The receiver's hook supplies thread and cwd. Core holds only a random endpoint
@@ -35,8 +34,8 @@ export async function probeNativeDelivery({ timeoutMs = 750, env = process.env,
   open = openCodexAppServer } = {}) {
   const unsupported = (reasonCode, clientVersion = null) => ({ supported: false, clientVersion,
     protocolContract: PROTOCOL_CONTRACT, executableFingerprint: null, modes: [], reasonCode });
-  const socketPath = controlSocketPath(env);
-  if (!await socketIsReady(socketPath)) return unsupported("native_endpoint_unavailable");
+  const socketPath = await readySocketPath(controlSocketPath(env));
+  if (socketPath === null) return unsupported("native_endpoint_unavailable");
   try {
     return await usingPeer(socketPath, timeoutMs, open, async peer => {
       const probe = await probeCodexQueue(peer);
@@ -46,7 +45,12 @@ export async function probeNativeDelivery({ timeoutMs = 750, env = process.env,
         modes: [...QUEUE_MODES], reasonCode: null };
     });
   } catch (error) {
-    return unsupported(error?.code === "ETIMEDOUT" ? "probe_timeout" : "feature_probe_failed");
+    if (error?.code === "ETIMEDOUT") return unsupported("probe_timeout");
+    // A service that died without cleaning up leaves its socket file behind,
+    // and a connect to it is refused. That is a missing service, the one fact
+    // whose advice (start the daemon) fixes it, not a failed feature probe.
+    return unsupported(safeReason(error) === "transport_unavailable"
+      ? "native_endpoint_unavailable" : "feature_probe_failed");
   }
 }
 
@@ -85,7 +89,7 @@ export async function verifyReceiver(peer, endpoint, { probe = probeCodexQueue,
       : result.reasonCode === "below_minimum_version" ? "handshake_version_mismatch"
         : "protocol_mismatch", servingVersion: null };
   }
-  if (compareStableVersions(result.serverVersion, CODEX_QUEUE_MINIMUM) < 0) {
+  if (compareVersions(result.serverVersion, CODEX_QUEUE_MINIMUM) < 0) {
     return { reasonCode: "handshake_version_mismatch", servingVersion: null };
   }
   const located = await locate(peer, { threadId: endpoint.threadId, cwd: endpoint.cwd });
@@ -99,12 +103,12 @@ export async function bindNativeSession({ event, clientPid, clientVersion, runti
   env = process.env, timeoutMs = 750, now = Date.now, open = openCodexAppServer } = {}) {
   const rejected = reason => closed(clientVersion, reason);
   if (!Number.isInteger(clientPid) || clientPid <= 0) return rejected("client_process_unknown");
-  if (parseStableVersion(clientVersion) === null) return rejected("version_unavailable");
+  if (versionOrder(clientVersion) === null) return rejected("version_unavailable");
   if (typeof event?.sessionId !== "string" || event.sessionId === "") return rejected("handshake_failed");
   const cwd = await canonicalCwd(event.cwd);
   if (cwd === null) return rejected("workspace_identity_unavailable");
-  const socketPath = await realpath(controlSocketPath(env)).catch(() => null);
-  if (!await socketIsReady(socketPath)) return rejected("handshake_failed");
+  const socketPath = await readySocketPath(controlSocketPath(env));
+  if (socketPath === null) return rejected("handshake_failed");
   try {
     return await usingPeer(socketPath, timeoutMs, open, async peer => {
       const endpoint = { schemaVersion: 1, endpointId: newEndpointId(), socketPath,

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

@@ -3,7 +3,7 @@ import { constants } from "node:fs";
 import { lstat, mkdir, open, realpath, rename, rm } from "node:fs/promises";
 import path from "node:path";
 
-import { PROTOCOL_CONTRACT, parseStableVersion } from "./app-server-client.mjs";
+import { PROTOCOL_CONTRACT, versionOrder } from "./app-server-client.mjs";
 
 const KEYS = ["schemaVersion", "endpointId", "socketPath", "threadId", "cwd",
   "clientVersion", "protocolContract", "leaseUntil"];
@@ -21,7 +21,7 @@ function valid(record) {
     && record.schemaVersion === 1 && ENDPOINT.test(record.endpointId)
     && absolute(record.socketPath) && absolute(record.cwd)
     && typeof record.threadId === "string" && /^[a-zA-Z0-9_-]{1,128}$/.test(record.threadId)
-    && parseStableVersion(record.clientVersion) !== null
+    && 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)
@@ -49,6 +49,16 @@ export async function socketIsReady(socketPath) {
   } catch { return false; }
 }
 
+/** The socket a control socket path leads to, or null. Codex 0.157.1 keeps a
+ * symlink at the path it reports and the socket itself under /private/tmp
+ * (measured 2026-09-26), so the path is followed once and the socket at its
+ * end is held to socketIsReady: an owned socket, never itself a link. */
+export async function readySocketPath(socketPath) {
+  if (!absolute(socketPath)) return null;
+  const resolved = await realpath(socketPath).catch(() => null);
+  return resolved !== null && await socketIsReady(resolved) ? resolved : null;
+}
+
 // A fresh, immutable registration for one hook binding. Refresh observes the
 // same registration again; it cannot overwrite a successor's random endpoint.
 export async function writeNativeEndpoint({ runtimeDir, record }) {