agents-can-communicate 0.7.1 → 0.8.1

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

@@ -0,0 +1,166 @@
+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";
+import { isReception } from "./inbox-settings.mjs";
+
+// One private record per hook binding, the way the Codex adapter keeps its
+// daemon endpoints: core holds only the random id, and the socket path, pid and
+// session id stay in a 0600 file under the workspace runtime directory.
+
+const KEYS = ["schemaVersion", "endpointId", "socketPath", "configDir", "clientPid", "sessionId",
+  "clientVersion", "protocolContract", "leaseUntil", "reception"];
+const ENDPOINT = /^claude_inbox_[a-f0-9]{32}$/;
+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();
+const invalid = () => new Error("invalid Claude inbox endpoint registration");
+
+export const newEndpointId = () => `claude_inbox_${randomBytes(16).toString("hex")}`;
+
+function valid(record) {
+  return record !== null && typeof record === "object" && !Array.isArray(record)
+    && Object.keys(record).length === KEYS.length && KEYS.every(key => Object.hasOwn(record, key))
+    && record.schemaVersion === 1 && ENDPOINT.test(record.endpointId)
+    && 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" && 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)
+    && Number.isFinite(Date.parse(record.leaseUntil))
+    && isReception(record.reception);
+}
+
+async function directory(runtimeDir, create = false) {
+  if (!absolute(runtimeDir)) throw invalid();
+  if (create) await mkdir(runtimeDir, { recursive: true, mode: 0o700 });
+  const root = await realpath(runtimeDir);
+  const dir = path.join(root, "claude-inbox-endpoints");
+  if (create) await mkdir(dir, { mode: 0o700 }).catch(error => {
+    if (error.code !== "EEXIST") throw error;
+  });
+  const info = await lstat(dir);
+  if (!info.isDirectory() || info.isSymbolicLink() || !own(info) || (info.mode & 0o022) !== 0) throw invalid();
+  return dir;
+}
+
+export async function writeInboxEndpoint({ runtimeDir, record }) {
+  if (!valid(record) || !await inboxSocketIsSafe(record.socketPath)) throw invalid();
+  const text = `${JSON.stringify(record)}\n`;
+  if (Buffer.byteLength(text) > MAX_BYTES) throw invalid();
+  const dir = await directory(runtimeDir, true);
+  const file = path.join(dir, `${record.endpointId}.json`);
+  const temporary = path.join(dir, `.${record.endpointId}.${randomBytes(8).toString("hex")}.tmp`);
+  let handle;
+  try {
+    handle = await open(temporary, "wx", 0o600);
+    await handle.writeFile(text, "utf8");
+    await handle.close(); handle = null;
+    await rename(temporary, file);
+  } finally {
+    await handle?.close().catch(() => null);
+    await rm(temporary, { force: true }).catch(() => null);
+  }
+}
+
+// An expired record is metadata for re-verification, never proof of reach.
+export async function readInboxEndpoint({ runtimeDir, endpointId }) {
+  if (typeof endpointId !== "string" || !ENDPOINT.test(endpointId)) return null;
+  let handle;
+  try {
+    const dir = await directory(runtimeDir);
+    handle = await open(path.join(dir, `${endpointId}.json`),
+      constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    const info = await handle.stat();
+    if (!info.isFile() || !own(info) || info.size > MAX_BYTES || (info.mode & 0o077) !== 0) return null;
+    const record = JSON.parse(await handle.readFile("utf8"));
+    return valid(record) && record.endpointId === endpointId ? record : null;
+  } catch {
+    return null;
+  } finally {
+    await handle?.close().catch(() => null);
+  }
+}
+
+export async function removeInboxEndpoint({ runtimeDir, endpointId }) {
+  if (typeof endpointId !== "string" || !ENDPOINT.test(endpointId)) return;
+  try {
+    const dir = await directory(runtimeDir);
+    await rm(path.join(dir, `${endpointId}.json`), { force: true });
+  } catch { /* retirement is already recorded; cleanup is best effort */ }
+  try {
+    await rm(path.join(await wakesDirectory(runtimeDir), endpointId), { recursive: true, force: true });
+  } catch { /* the same */ }
+}
+
+const processExists = pid => {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error) {
+    return error.code === "EPERM";
+  }
+};
+
+/**
+ * A Claude Code process that crashed ran no SessionEnd, so its binding was never
+ * retired. Only a record whose process is gone is removed: a live session whose
+ * registry briefly names another conversation (right after /resume) keeps its own.
+ */
+export async function sweepDeadEndpoints({ runtimeDir, exists = processExists, limit = 64 }) {
+  let names;
+  try {
+    names = await readdir(await directory(runtimeDir));
+  } catch {
+    return;
+  }
+  for (const name of names.filter(item => /^claude_inbox_[a-f0-9]{32}\.json$/.test(item)).slice(0, limit)) {
+    const endpointId = name.slice(0, -".json".length);
+    const record = await readInboxEndpoint({ runtimeDir, endpointId });
+    if (record !== null && !exists(record.clientPid)) await removeInboxEndpoint({ runtimeDir, endpointId });
+  }
+}
+
+// One empty marker per message a binding woke. A wake leaves the receipt
+// queued until the receiver's hook commits it, so a replayed send reaches the
+// transport again; the marker keeps it to one wake per message and binding.
+const WAKE_MESSAGE = /^[A-Za-z0-9_-]{1,200}$/;
+
+async function wakesDirectory(runtimeDir, create = false) {
+  const dir = path.join(path.dirname(await directory(runtimeDir, create)), "claude-inbox-wakes");
+  if (create) await mkdir(dir, { mode: 0o700 }).catch(error => {
+    if (error.code !== "EEXIST") throw error;
+  });
+  const info = await lstat(dir);
+  if (!info.isDirectory() || info.isSymbolicLink() || !own(info) || (info.mode & 0o022) !== 0) throw invalid();
+  return dir;
+}
+
+/** True when this call is the first to wake the binding for the message. */
+export async function claimWake({ runtimeDir, endpointId, messageId }) {
+  if (!ENDPOINT.test(endpointId) || !WAKE_MESSAGE.test(messageId)) throw invalid();
+  const dir = path.join(await wakesDirectory(runtimeDir, true), endpointId);
+  await mkdir(dir, { mode: 0o700 }).catch(error => {
+    if (error.code !== "EEXIST") throw error;
+  });
+  try {
+    await (await open(path.join(dir, messageId), "wx", 0o600)).close();
+    return true;
+  } catch (error) {
+    if (error.code === "EEXIST") return false;
+    throw error;
+  }
+}
+
+export async function releaseWake({ runtimeDir, endpointId, messageId }) {
+  if (!ENDPOINT.test(endpointId) || !WAKE_MESSAGE.test(messageId)) return;
+  try {
+    await rm(path.join(await wakesDirectory(runtimeDir), endpointId, messageId), { force: true });
+  } catch { /* a marker left behind only suppresses a repeat wake */ }
+}

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

@@ -0,0 +1,71 @@
+import { constants } from "node:fs";
+import { lstat, open, realpath } from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+
+// Claude Code's own record of a live session: `<config>/sessions/<pid>.json`
+// names the session id and the inbox socket it listens on. ACC reads that file
+// and nothing beside it - never the `<pid>.<hash>.key` next to it.
+
+const MAX_BYTES = 16_384;
+const own = info => typeof process.getuid !== "function" || info.uid === process.getuid();
+
+export const claudeConfigDir = env => typeof env?.CLAUDE_CONFIG_DIR === "string"
+  && path.isAbsolute(env.CLAUDE_CONFIG_DIR)
+  ? env.CLAUDE_CONFIG_DIR : path.join(os.homedir(), ".claude");
+
+/** The registry entry for one pid, or null. Bounded, owner-checked, never through a link. */
+export async function readSessionRecord({ configDir, clientPid }) {
+  if (!Number.isInteger(clientPid) || clientPid <= 0 || typeof configDir !== "string") return null;
+  let handle;
+  try {
+    handle = await open(path.join(configDir, "sessions", `${clientPid}.json`),
+      constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    const info = await handle.stat();
+    if (!info.isFile() || !own(info) || info.size > MAX_BYTES) return null;
+    const record = JSON.parse(await handle.readFile("utf8"));
+    return record?.pid === clientPid && typeof record.sessionId === "string" && record.sessionId !== ""
+      && typeof record.messagingSocketPath === "string" && path.isAbsolute(record.messagingSocketPath)
+      ? { pid: record.pid, sessionId: record.sessionId, messagingSocketPath: record.messagingSocketPath,
+        cwd: typeof record.cwd === "string" && path.isAbsolute(record.cwd) ? record.cwd : null }
+      : null;
+  } catch {
+    return null;
+  } finally {
+    await handle?.close().catch(() => null);
+  }
+}
+
+/** A socket this user owns, reached without a link, closed to group and others. */
+export async function inboxSocketIsSafe(socketPath) {
+  if (typeof socketPath !== "string" || !path.isAbsolute(socketPath)) return false;
+  try {
+    const info = await lstat(socketPath);
+    return info.isSocket() && !info.isSymbolicLink() && own(info) && (info.mode & 0o077) === 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Whether this socket is the inbox of this session, right now.
+ *
+ * The socket path alone proves nothing: pids are reused, and a new process
+ * gets a new registry entry under the same name. Requiring the registry to
+ * name both this session id and this socket is what keeps a wake from reaching
+ * whatever process holds the pid later. Returns null, or the reason it is not.
+ *
+ * `anyConversation` is for the bind alone. Claude Code runs SessionStart for a
+ * /resume before it rewrites the entry, so there the hook's own process and
+ * socket are the proof; every offer and refresh still requires the session id.
+ */
+export async function verifyInbox({ configDir, clientPid, sessionId, socketPath, anyConversation = false }) {
+  if (!await inboxSocketIsSafe(socketPath)) return "native_endpoint_unavailable";
+  const record = await readSessionRecord({ configDir, clientPid });
+  if (record === null || (!anyConversation && record.sessionId !== sessionId)) {
+    return "native_session_unavailable";
+  }
+  const [registered, expected] = await Promise.all([
+    realpath(record.messagingSocketPath).catch(() => null), realpath(socketPath).catch(() => null)]);
+  return registered !== null && registered === expected ? null : "native_session_unavailable";
+}

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

@@ -0,0 +1,109 @@
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+
+// What Claude Code does with a wake from a sender that attests no permission
+// mode - ACC never attests one. A session that bypasses permission prompts
+// holds it for approval; `crossSessionInbound` overrides that both ways. ACC
+// reads the same inputs so the sender is told what will happen, and never
+// changes any of them.
+
+const MAX_BYTES = 256 * 1024;
+const RECEPTIONS = Object.freeze(["delivered", "held", "refused"]);
+
+export const MANAGED_SETTINGS = Object.freeze({
+  darwin: "/Library/Application Support/ClaudeCode/managed-settings.json",
+  linux: "/etc/claude-code/managed-settings.json",
+  win32: "C:\\Program Files\\ClaudeCode\\managed-settings.json",
+});
+
+async function readSettings(file) {
+  try {
+    const text = await readFile(file, "utf8");
+    if (Buffer.byteLength(text) > MAX_BYTES) return null;
+    const value = JSON.parse(text);
+    return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+const text = value => (typeof value === "string" && value !== "" ? value : null);
+
+/**
+ * The two inputs, each from the first file that sets it, in Claude Code's own
+ * order: managed policy, then the project's local and shared settings, then
+ * the user's.
+ */
+export async function readInboundSettings({ configDir, projectDir, managedSettingsPath }) {
+  const files = [managedSettingsPath,
+    ...(typeof projectDir === "string" && path.isAbsolute(projectDir)
+      ? [path.join(projectDir, ".claude", "settings.local.json"),
+        path.join(projectDir, ".claude", "settings.json")] : []),
+    path.join(configDir, "settings.json")].filter(file => typeof file === "string");
+  const layers = await Promise.all(files.map(readSettings));
+  const first = pick => layers.map(layer => (layer === null ? null : pick(layer))).find(value => value !== null)
+    ?? null;
+  return {
+    crossSessionInbound: first(layer => text(layer.crossSessionInbound)),
+    defaultMode: first(layer => text(layer.permissions?.defaultMode)),
+  };
+}
+
+/**
+ * The permission mode a Claude Code process was started with, from its own
+ * arguments, or null. Only the two flags are read; nothing else is kept.
+ */
+export function permissionModeFromArgs(args) {
+  if (!Array.isArray(args)) return null;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--dangerously-skip-permissions") return "bypassPermissions";
+    if (arg === "--permission-mode") return text(args[index + 1]);
+    if (typeof arg === "string" && arg.startsWith("--permission-mode=")) {
+      return text(arg.slice("--permission-mode=".length));
+    }
+  }
+  return null;
+}
+
+/** A process's arguments as `ps` prints them, split on spaces, or null. */
+export function readProcessArgs(pid, { timeoutMs = 500 } = {}) {
+  if (!Number.isInteger(pid) || pid <= 0 || process.platform === "win32") return Promise.resolve(null);
+  return new Promise(resolve => {
+    execFile("ps", ["-o", "args=", "-p", String(pid)], { timeout: timeoutMs, maxBuffer: 64 * 1024 },
+      (error, stdout) => resolve(error ? null : String(stdout).trim().split(/\s+/).filter(Boolean)));
+  });
+}
+
+export function receptionOf({ permissionMode, crossSessionInbound }) {
+  if (crossSessionInbound === "accept") return "delivered";
+  if (crossSessionInbound === "refuse") return "refused";
+  if (crossSessionInbound === "hold" || permissionMode === "bypassPermissions") return "held";
+  return "delivered";
+}
+
+export const isReception = value => RECEPTIONS.includes(value);
+
+/**
+ * What `acc doctor` tells a person who turned live delivery on: the machine-wide
+ * view, from managed policy and the user's settings. A project can still set
+ * its own value; the bind reads that one per session.
+ */
+export async function inboundStatus({ configDir, managedSettingsPath }) {
+  const userFile = path.join(configDir, "settings.json");
+  for (const file of [managedSettingsPath, userFile].filter(item => typeof item === "string")) {
+    const value = text((await readSettings(file))?.crossSessionInbound);
+    if (value === "accept") return { state: "accepted", diagnostic: null };
+    if (value === "refuse") {
+      return { state: "refused", diagnostic: `crossSessionInbound is "refuse" in ${file}, so `
+        + "Claude Code drops every ACC wake; messages arrive with each next turn; set it to "
+        + "\"accept\" for live delivery" };
+    }
+    if (value !== null) break;
+  }
+  return { state: "attention", diagnostic: "a session that bypasses permission prompts asks "
+    + `before each ACC wake; add "crossSessionInbound": "accept" to ${userFile} to take wakes `
+    + "without asking; the next turn shows the message either way" };
+}
+

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

@@ -7,13 +7,14 @@ import path from "node:path";
 import { AccError, EXIT } from "@agents-can-communicate/protocol";
 import { fileURLToPath } from "node:url";
 
-import { acccreatedFile, bakeSkillCommand, blankJson, defaultBootstrap, defaultChannel,
+import { acccreatedFile, bakeSkillCommand, blankJson,
   mergeOwnedEntries, ownedEntries,
   keepVersions, ownVersion, stampPluginVersion,
   removeIfEmpty,
   removeInstalledTree,
   removeOwnedEntries, writeCliShim, writeForeignJson, writeHookShim }
   from "@agents-can-communicate/adapter-sdk";
+import { MANAGED_SETTINGS, inboundStatus } from "./inbox-settings.mjs";
 
 const bundle = fileURLToPath(new URL("../plugin", import.meta.url));
 const manifest = fileURLToPath(new URL("../plugin/.claude-plugin/plugin.json",
@@ -22,9 +23,6 @@ const manifest = fileURLToPath(new URL("../plugin/.claude-plugin/plugin.json",
 const PLUGIN_NAME = "agents-can-communicate";
 const MARKETPLACE = "acc-local";
 const QUALIFIED = `${PLUGIN_NAME}@${MARKETPLACE}`;
-const CHANNEL_ACTIVATION_CHECK = "Check Claude's Channels startup notice for ACC; "
-  + "an MCP connection does not verify inbound delivery. If Channels are unavailable "
-  + "or blocked, resolve that client warning before expecting live messages.";
 
 /**
  * How this client actually installs a plugin.
@@ -147,24 +145,21 @@ const marketplaceManifest = () => ({
   }],
 });
 
-// The channel MCP entry Claude Code loads only when the session is started with
-// the captured development-channel flag. Written with the pinned Node and the
-// installed Channel binary, so the generated file carries no repository path;
-// removed entirely for a non-live install so a plain launch spawns nothing.
+// Up to 0.7.x a live install wrote the Channel MCP server here, and Claude
+// Code spawned it for every session that enabled the plugin. The inbox wake
+// needs no MCP server, so no plugin copy ACC keeps may name one.
 const mcpPath = target => path.join(target, ".mcp.json");
-async function writeChannelMcp(target, { node, channel }) {
-  await writeJson(mcpPath(target), { mcpServers: { "acc-channel": {
-    command: node, args: [channel] } } });
+
+async function removeChannelConfig(versionsRoot) {
+  const versions = await readdir(versionsRoot).catch(() => []);
+  await Promise.all(versions.map(version => rm(mcpPath(path.join(versionsRoot, version)),
+    { force: true })));
 }
 
 /** A plugin tree with the shim written and the skill's command baked in. */
-async function layOutPlugin(target, { runner, node, cli, channel, live }) {
+async function layOutPlugin(target, { runner, node, cli }) {
   await rm(target, { recursive: true, force: true });
   await cp(bundle, target, { recursive: true });
-  // The bundle ships a placeholder .mcp.json; the real one is written only for a
-  // live install, and a non-live tree carries none.
-  await rm(mcpPath(target), { force: true });
-  if (live) await writeChannelMcp(target, { node, channel });
   // The skill ships with a placeholder where the command belongs: `acc` is not
   // on PATH everywhere, and an agent that cannot run it improvises. The shim
   // carries the pinning so each example can name one path. No data home is
@@ -181,9 +176,8 @@ async function layOutPlugin(target, { runner, node, cli, channel, live }) {
     version: await pluginVersion(), io: { readFile, writeFile } });
 }
 
-export async function installClaudePlugin({ configDir, runner, cli, keepPreviousVersion = null, node = process.execPath,
-  channel = defaultChannel(), livePolicy = "off", now = new Date() }) {
-  const live = livePolicy === "actionable" || livePolicy === "all";
+export async function installClaudePlugin({ configDir, runner, cli, keepPreviousVersion = null,
+  node = process.execPath, now = new Date() }) {
   // Everything this will merge into, read before a byte is written. A settings
   // file that will not parse used to be discovered after the plugin tree was
   // already on disk, and the install then failed with nineteen files left
@@ -200,12 +194,12 @@ export async function installClaudePlugin({ configDir, runner, cli, keepPrevious
   const source = sourceDir(configDir);
   const cached = cachePath(configDir, version);
 
-  await layOutPlugin(source, { runner, node, cli, channel, live });
+  await layOutPlugin(source, { runner, node, cli });
   await writeJson(marketplaceFile(configDir), marketplaceManifest());
   // The copy the client runs from. Written here rather than asking the user to
   // run `claude plugin install`, exactly as the Codex adapter does, because the
   // command's only effect is this copy plus the two registry entries below.
-  await layOutPlugin(cached, { runner, node, cli, channel, live });
+  await layOutPlugin(cached, { runner, node, cli });
   // The copy just written, plus the one an upgrade moved off. A client caches a
   // plugin under its version, so every upgrade would otherwise leave the previous
   // release's tree beside this one - invisible while the version never moved,
@@ -214,6 +208,10 @@ export async function installClaudePlugin({ configDir, runner, cli, keepPrevious
   // anything older than that holds no session and is litter.
   await keepVersions({ root: path.dirname(cached), keep: [version, keepPreviousVersion],
     io: { readdir, rm } });
+  // The copy an upgrade moved off stays for sessions already running from it,
+  // but its Channel config would still start a Channel for any session that
+  // reads it. Those sessions keep what they loaded; nothing new starts one.
+  await removeChannelConfig(path.dirname(cached));
 
   await writeClientJson(knownMarketplacesPath(configDir), {
     ...known,
@@ -254,12 +252,9 @@ export async function installClaudePlugin({ configDir, runner, cli, keepPrevious
 
   return { ok: true,
     changes: [source, cached, marketplaceFile(configDir),
-      knownMarketplacesPath(configDir), installedPluginsPath(configDir), file,
-      ...(live ? [mcpPath(source), mcpPath(cached)] : [])],
-    needsAction: live ? [CHANNEL_ACTIVATION_CHECK] : [],
-    diagnostics: live
-      ? ["native channel wired; Claude's experimental development-channel warning still applies"]
-      : [] };
+      knownMarketplacesPath(configDir), installedPluginsPath(configDir), file],
+    needsAction: [],
+    diagnostics: [] };
 }
 
 export async function uninstallClaudePlugin({ configDir, keep = [] }) {
@@ -297,16 +292,15 @@ export async function uninstallClaudePlugin({ configDir, keep = [] }) {
   return { ok: true, changes, diagnostics: [] };
 }
 
-export async function detectClaude({ configDir }) {
+export async function detectClaude({ configDir, managedSettingsPath = MANAGED_SETTINGS[process.platform] }) {
   const settings = await readJson(settingsPath(configDir), null);
   const enabled = settings?.enabledPlugins?.[QUALIFIED] === true;
   const registered = Object.hasOwn(
     (await readJson(installedPluginsPath(configDir), { plugins: {} })).plugins ?? {},
     QUALIFIED);
-  const channelConfigured = enabled && registered
-    && (await readJson(mcpPath(sourceDir(configDir)), null))?.mcpServers?.["acc-channel"] != null;
   return { ok: true, changes: [],
-    needsAction: channelConfigured ? [CHANNEL_ACTIVATION_CHECK] : [],
+    inboundDelivery: await inboundStatus({ configDir, managedSettingsPath }),
+    needsAction: [],
     diagnostics: [enabled && registered
       ? "acc plugin registered and enabled"
       : "acc plugin not registered"] };

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/adapter-codex",
-  "version": "0.7.1",
+  "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"