agents-can-communicate 0.4.3 → 0.5.0

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

@@ -2,22 +2,27 @@ import { defineAdapter, projectContext, projectContextResult }
   from "@agents-can-communicate/adapter-sdk";
 import { probeNativeDelivery, planNativeActivation, bindNativeSession, refreshNativeSession, retireNativeSession, offerMessage } from "./native-delivery.mjs";
 import certification from "../certification.json" with { type: "json" };
+import { createCodexMaintenance } from "./maintenance.mjs";
+export { sameMaintenanceIdentity } from "./maintenance.mjs";
 
-import { PROTOCOL_CONTRACT } from "./app-server-client.mjs";
+import { CODEX_QUEUE_MINIMUM, PROTOCOL_CONTRACT } from "./app-server-client.mjs";
 import { allowOutcome, denyOutcome, injectOutcome, normalizeCodexHook }
   from "./hooks.mjs";
 import { planCodexInstall, detectCodex, installCodexPlugin, preflightCodexUninstall,
   uninstallCodexPlugin } from "./install.mjs";
 // Public native wiring is enabled only with installed-product capture evidence.
 
+// Re-exported so existing importers of CODEX_QUEUE_MINIMUM keep resolving; the
+// value now lives in app-server-client.mjs alongside the other version rules.
+export { CODEX_QUEUE_MINIMUM };
 export const CODEX_VERSION = "0.147.0";
-export const CODEX_QUEUE_MINIMUM = "0.152.1";
 export const CODEX_DELIVERY_FALLBACK = Object.freeze({
   diagnostic: "Codex native delivery requires codex-cli 0.152.1 or newer on darwin-arm64, "
     + "recorded recipient consent and a reachable LocalDaemon session with exact thread, cwd, "
     + "process, version and protocol verification. Embedded or unreachable sessions retain "
-    + "durable messages. ACC does not start, restart or stop the vendor daemon and adds no "
-    + "launch arguments; fallback is exact-certified next-turn delivery or acc inbox",
+    + "durable messages. Native delivery does not start, restart or stop the vendor daemon and adds no "
+    + "launch arguments; fallback is exact-certified next-turn delivery or acc inbox. "
+    + "Explicitly confirmed acc update maintenance has a separate daemon restart check",
 });
 
 /**
@@ -61,6 +66,7 @@ export function createCodexAdapter() {
     },
     probeNativeDelivery, planNativeActivation, bindNativeSession,
     refreshNativeSession, retireNativeSession, offerMessage,
+    ...createCodexMaintenance(),
     startSession: async () => ({ ok: true, changes: [], diagnostics: [] }),
     endSession: async () => ({ ok: true, changes: [], diagnostics: [] }),
     guardWrite: async () => ({ ok: true, changes: [], diagnostics: [] }),

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

@@ -12,6 +12,10 @@ import { openWebSocketPeer } from "./ws-json-rpc.mjs";
 
 export const PROTOCOL_CONTRACT = "codex-app-server-thread-queue-v1";
 export const MINIMUM_VERSION = "0.152.1";
+// The captured native-delivery contract's floor. Shared with MINIMUM_VERSION
+// today, but named separately: this is the version a binding was verified
+// against, not the probe's own support floor.
+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*)$/;

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

@@ -0,0 +1,120 @@
+import { execFile } from "node:child_process";
+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";
+
+export const MINIMUM_MAINTENANCE_CLI = "0.154.0";
+export const absolute = value => typeof value === "string" && path.isAbsolute(value)
+  && !/[\0\r\n]/.test(value);
+export const failMaintenance = reasonCode => { throw Object.assign(new Error(reasonCode), { reasonCode }); };
+const own = info => typeof process.getuid !== "function" || info.uid === process.getuid();
+export const startTimeValid = value => typeof value === "string"
+  && /^[A-Z][a-z]{2} [A-Z][a-z]{2} [ \d]\d \d\d:\d\d:\d\d \d{4}$/.test(value);
+export const managedExecutablePaths = codexHome => ["bin/codex", "codex"].map(name =>
+  path.join(codexHome, "packages/standalone/current", name));
+
+export function runMaintenanceCommand(command, args, options) {
+  return new Promise(resolve => execFile(command, args,
+    { ...options, timeout: 20_000, maxBuffer: 131_072, windowsHide: true },
+    (error, stdout, stderr) => resolve({ status: error ?
+      (typeof error.code === "number" ? error.code : null) : 0, stdout, stderr })));
+}
+
+export async function maintenanceContext(context = {}) {
+  const env = context.env ?? process.env;
+  const home = context.home ?? env.HOME ?? os.homedir();
+  let codexHome = env.CODEX_HOME ?? path.join(home, ".codex");
+  if (!absolute(home) || !absolute(codexHome)) failMaintenance("invalid_service_home");
+  try { codexHome = await realpath(codexHome); }
+  catch (error) { if (error.code !== "ENOENT") throw error; }
+  const [binPath, legacyPath] = managedExecutablePaths(codexHome);
+  const managedPath = await metadataExists(binPath) ? binPath : legacyPath;
+  return { codexHome, socketPath: path.join(codexHome, "app-server-control/app-server-control.sock"),
+    pidPath: path.join(codexHome, "app-server-daemon/app-server.pid"),
+    managedPath,
+    platform: context.platform ?? `${process.platform}-${process.arch}`,
+    options: { cwd: codexHome, env: { ...env, HOME: home, CODEX_HOME: codexHome } } };
+}
+
+export async function metadataExists(file) {
+  try { await lstat(file); return true; }
+  catch (error) { if (error.code === "ENOENT") return false; throw error; }
+}
+
+async function resolveCli(pathEnv) {
+  for (const directory of String(pathEnv ?? "").split(path.delimiter)) {
+    if (!absolute(directory)) continue;
+    const candidate = path.join(directory, "codex");
+    try {
+      await access(candidate, constants.X_OK);
+      const resolved = await realpath(candidate);
+      if ((await lstat(resolved)).isFile()) return resolved;
+    } catch { /* another PATH entry may be usable */ }
+  }
+  failMaintenance("maintenance_cli_unavailable");
+}
+
+const cliVersion = response => response.status === 0
+  ? /^codex-cli (\d+\.\d+\.\d+)\s*$/.exec(response.stdout)?.[1] ?? null : null;
+
+export async function probeMaintenanceInstall(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) {
+    failMaintenance("maintenance_cli_unsupported");
+  }
+  const help = await run(cliPath, ["app-server", "daemon", "--help"], paths.options);
+  if (help.status !== 0 || ["start", "stop", "version"].some(command =>
+    !new RegExp(`^\\s+${command}\\s+`, "m").test(help.stdout))) failMaintenance("maintenance_cli_unsupported");
+  const managedVersion = cliVersion(await run(paths.managedPath, ["--version"], paths.options));
+  if (managedVersion !== version) failMaintenance("managed_binary_mismatch");
+  return { cliPath, cliVersion: version, managedVersion };
+}
+
+export async function readMaintenancePid(file) {
+  let handle;
+  try {
+    handle = await open(file, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    const info = await handle.stat();
+    if (!info.isFile() || !own(info) || info.size > 4_096 || (info.mode & 0o022) !== 0) {
+      failMaintenance("daemon_identity_unavailable");
+    }
+    const value = JSON.parse(await handle.readFile("utf8"));
+    if (!Number.isSafeInteger(value.pid) || value.pid < 2 || !startTimeValid(value.processStartTime)) {
+      failMaintenance("daemon_identity_unavailable");
+    }
+    return { pid: value.pid, processStartTime: value.processStartTime };
+  } finally { await handle?.close(); }
+}
+
+export async function observeMaintenanceProcess(pid, paths, run) {
+  const response = await run("/bin/ps", ["-p", String(pid), "-o", "lstart=,command="], paths.options);
+  if (response.status === 1 && response.stdout === "" && response.stderr === "") return { state: "dead" };
+  if (response.status !== 0) return { state: "unknown" };
+  const match = /^(.{24})\s+(.+)$/.exec(response.stdout.trim());
+  if (!match || !startTimeValid(match[1])) return { state: "unknown" };
+  return { state: "alive", processStartTime: match[1], command: match[2] };
+}
+
+export async function verifyMaintenanceProcess(snapshot, paths, run) {
+  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;
+  if (process.state !== "alive" || process.processStartTime !== snapshot.processStartTime
+    || !managedExecutablePaths(paths.codexHome).includes(executable)
+    || await realpath(executable) !== 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}`)) {
+    failMaintenance("daemon_socket_unproven");
+  }
+}
+
+export async function approvedProcessIsDead(expected, paths, run) {
+  const observed = await observeMaintenanceProcess(expected.pid, paths, run);
+  return observed.state === "dead" || (observed.state === "alive"
+    && observed.processStartTime !== expected.processStartTime);
+}

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

@@ -0,0 +1,49 @@
+import { initializeCodex } from "./app-server-client.mjs";
+import { failMaintenance } from "./maintenance-host.mjs";
+
+async function loadedThreads(peer) {
+  const ids = [], cursors = new Set();
+  let cursor = null;
+  for (let page = 0; page < 20; page += 1) {
+    const response = await peer.request("thread/loaded/list", { limit: 100, ...(cursor ? { cursor } : {}) });
+    if (!Array.isArray(response?.data) || response.data.some(id => typeof id !== "string" || !id)) {
+      failMaintenance("maintenance_protocol_unavailable");
+    }
+    ids.push(...response.data);
+    cursor = response.nextCursor ?? null;
+    if (cursor === null) {
+      if (new Set(ids).size !== ids.length) failMaintenance("maintenance_protocol_unavailable");
+      return ids.sort();
+    }
+    if (typeof cursor !== "string" || !cursor || cursors.has(cursor)) failMaintenance("maintenance_protocol_unavailable");
+    cursors.add(cursor);
+  }
+  failMaintenance("maintenance_protocol_unavailable");
+}
+
+// The caller receives counts only. No thread/list previews, turns, queue bodies,
+// notification history, or vendor errors are retained in maintenance snapshots.
+export async function maintenanceWorkload(snapshot, open) {
+  let peer;
+  try {
+    peer = await open({ socketPath: snapshot.socketPath });
+    if (await initializeCodex(peer) !== snapshot.serverVersion) failMaintenance("daemon_version_changed");
+    const ids = await loadedThreads(peer);
+    let busyThreads = 0, queuedRequests = 0;
+    for (const threadId of ids) {
+      const response = await peer.request("thread/read", { threadId, includeTurns: false });
+      const thread = response?.thread;
+      if (thread?.id !== threadId || !Array.isArray(thread.turns) || thread.turns.length !== 0
+        || !["idle", "active"].includes(thread.status?.type)) failMaintenance("maintenance_protocol_unavailable");
+      if (thread.status.type === "active") busyThreads += 1;
+      const queue = await peer.request("thread/queue/list", { threadId });
+      if (!Array.isArray(queue?.data) || queue.nextCursor != null
+        || queue.data.some(entry => typeof entry?.id !== "string" || !entry.id)) {
+        failMaintenance("maintenance_protocol_unavailable");
+      }
+      queuedRequests += queue.data.length;
+    }
+    if (JSON.stringify(await loadedThreads(peer)) !== JSON.stringify(ids)) failMaintenance("loaded_threads_changed");
+    return { busyThreads, queuedRequests };
+  } finally { await peer?.close(); }
+}

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

@@ -0,0 +1,108 @@
+import path from "node:path";
+import { openCodexAppServer, parseStableVersion } from "./app-server-client.mjs";
+import { socketIsReady } from "./native-endpoint.mjs";
+import { absolute, approvedProcessIsDead, failMaintenance, maintenanceContext,
+  managedExecutablePaths, metadataExists, probeMaintenanceInstall, readMaintenancePid, runMaintenanceCommand,
+  startTimeValid, verifyMaintenanceProcess } from "./maintenance-host.mjs";
+import { maintenanceWorkload } from "./maintenance-threads.mjs";
+
+const identityKeys = ["serviceId", "pid", "processStartTime", "codexHome", "cliPath", "cliVersion",
+  "serverVersion", "managedPath", "managedVersion", "socketPath"];
+const installationKeys = ["codexHome", "cliPath", "cliVersion", "managedPath", "managedVersion", "socketPath"];
+const refused = (reasonCode, snapshot) => ({ ok: false, reasonCode, ...(snapshot ? { snapshot } : {}) });
+const sameFields = (left, right, fields) => fields.every(key => left?.[key] === right?.[key]);
+
+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]))
+    && value.managedVersion === value.cliVersion
+    && managedExecutablePaths(value.codexHome).includes(value.managedPath)
+    && value.socketPath === path.join(value.codexHome, "app-server-control/app-server-control.sock");
+}
+
+export function sameMaintenanceIdentity(expected, current) {
+  return validApproval(expected) && validApproval(current) && sameFields(expected, current, identityKeys);
+}
+
+export function createCodexMaintenance({ run = runMaintenanceCommand, open = openCodexAppServer } = {}) {
+  async function inspectMaintenance(context) {
+    let snapshot = { serviceId: "codex-app-server", state: "unsupported", reasonCode: null,
+      pid: null, processStartTime: null, codexHome: null, cliPath: null, cliVersion: null,
+      serverVersion: null, managedPath: null, managedVersion: null, socketPath: null,
+      busyThreads: 0, queuedRequests: 0 };
+    try {
+      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");
+      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");
+      const observed = JSON.parse(version.stdout);
+      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");
+      snapshot.serverVersion = observed.appServerVersion;
+      Object.assign(snapshot, await readMaintenancePid(paths.pidPath));
+      await verifyMaintenanceProcess(snapshot, paths, run);
+      Object.assign(snapshot, await maintenanceWorkload(snapshot, open));
+      const finalPid = await readMaintenancePid(paths.pidPath);
+      if (!sameFields(snapshot, finalPid, ["pid", "processStartTime"])) failMaintenance("service_identity_changed");
+      await verifyMaintenanceProcess(snapshot, paths, run);
+      snapshot.state = snapshot.busyThreads || snapshot.queuedRequests ? "busy" : "ready";
+      snapshot.reasonCode = snapshot.state === "busy" ? "service_busy" : null;
+    } catch (error) { snapshot.reasonCode = error.reasonCode ?? "maintenance_inspection_failed"; }
+    return snapshot;
+  }
+
+  async function stopForMaintenance({ context, expected } = {}) {
+    let stopAttempted = false;
+    const refuseStop = (reasonCode, snapshot) => ({ ...refused(reasonCode, snapshot), stopAttempted });
+    if (!validApproval(expected)) return refuseStop("invalid_maintenance_approval");
+    try {
+      const current = await inspectMaintenance(context);
+      if (!sameMaintenanceIdentity(expected, current)) return refuseStop("service_identity_changed", current);
+      if (current.state !== "ready" || current.busyThreads !== 0 || current.queuedRequests !== 0) {
+        return refuseStop("service_busy", current);
+      }
+      const paths = await maintenanceContext(context);
+      stopAttempted = true;
+      const stopped = await run(current.cliPath, ["app-server", "daemon", "stop"], paths.options);
+      if (stopped.status !== 0) return refuseStop("daemon_stop_failed");
+      if (!await approvedProcessIsDead(expected, paths, run)) return refuseStop("daemon_death_unverified");
+      return { ok: true, reasonCode: null, stopAttempted };
+    } catch { return refuseStop("daemon_stop_failed"); }
+  }
+
+  async function startAfterMaintenance({ context, expected } = {}) {
+    if (!validApproval(expected)) return refused("invalid_maintenance_approval");
+    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);
+      if (existing) {
+        if (["ready", "busy"].includes(existing.state) && sameFields(expected, existing, installationKeys)
+          && existing.serverVersion === expected.cliVersion) return { ok: true, reasonCode: null, snapshot: existing };
+        return refused("service_identity_changed", existing);
+      }
+      if (!await approvedProcessIsDead(expected, paths, run)) return refused("daemon_death_unverified");
+      const started = await run(install.cliPath, ["app-server", "daemon", "start"], paths.options);
+      if (started.status !== 0) return refused("daemon_start_failed");
+      const current = await inspectMaintenance(pinned);
+      if (!current || !["ready", "busy"].includes(current.state)
+        || !sameFields(expected, current, installationKeys) || current.serverVersion !== expected.cliVersion) {
+        return refused("daemon_start_unverified", current);
+      }
+      return { ok: true, reasonCode: null, snapshot: current };
+    } catch { return refused("daemon_start_failed"); }
+  }
+
+  return { inspectMaintenance, stopForMaintenance, startAfterMaintenance };
+}

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

@@ -1,9 +1,10 @@
 import { realpath } from "node:fs/promises";
 import { decisionBody } from "@agents-can-communicate/adapter-sdk";
 
-import { MINIMUM_VERSION, PROTOCOL_CONTRACT, QUEUE_MODES, addCodexQueueMessage,
-  canonicalCwd, controlSocketPath, locateCodexThread, openCodexAppServer,
-  parseStableVersion, probeCodexQueue, safeReason, serverVersionOf } from "./app-server-client.mjs";
+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,
   writeNativeEndpoint } from "./native-endpoint.mjs";
 
@@ -62,13 +63,35 @@ export function planNativeActivation({ detection }) {
   ] };
 }
 
-async function verifyReceiver(peer, endpoint) {
-  const probe = await probeCodexQueue(peer, { threadId: endpoint.threadId });
-  if (!probe.supported) return probe.reasonCode === "probe_timeout" ? "handshake_timeout" : "protocol_mismatch";
-  if (probe.serverVersion !== endpoint.clientVersion) return "handshake_version_mismatch";
-  const located = await locateCodexThread(peer, { threadId: endpoint.threadId, cwd: endpoint.cwd });
-  return located.found ? null : located.reasonCode === "cwd_mismatch"
-    ? "workspace_identity_unavailable" : "handshake_failed";
+// A daemon that restarted onto a newer build still satisfies the captured
+// contract. The thread it may have lost is reported separately by
+// locateCodexThread, so refusing on the version alone only hides the real
+// reason. Returns the version that actually answered as `servingVersion`
+// (null when refused) instead of mutating the endpoint it was handed, so a
+// caller can decide what to persist on the one path that owns persistence,
+// after its own validation has already run.
+export async function verifyReceiver(peer, endpoint, { probe = probeCodexQueue,
+  locate = locateCodexThread } = {}) {
+  const result = await probe(peer, { threadId: endpoint.threadId });
+  if (!result.supported) {
+    // probeCodexQueue applies the same floor and answers first, so a daemon
+    // serving below the minimum arrives here as a refused probe rather than
+    // reaching the explicit check below. Reporting that as a protocol
+    // mismatch named the wrong condition everywhere it surfaced - doctor,
+    // the offer's safe error code, the recorded failure - and left the
+    // version answer this function already knows how to give unreachable.
+    return { reasonCode: result.reasonCode === "probe_timeout" ? "handshake_timeout"
+      : result.reasonCode === "below_minimum_version" ? "handshake_version_mismatch"
+        : "protocol_mismatch", servingVersion: null };
+  }
+  if (compareStableVersions(result.serverVersion, CODEX_QUEUE_MINIMUM) < 0) {
+    return { reasonCode: "handshake_version_mismatch", servingVersion: null };
+  }
+  const located = await locate(peer, { threadId: endpoint.threadId, cwd: endpoint.cwd });
+  return located.found
+    ? { reasonCode: null, servingVersion: result.serverVersion }
+    : { reasonCode: located.reasonCode === "cwd_mismatch" ? "workspace_identity_unavailable" : "handshake_failed",
+        servingVersion: null };
 }
 
 export async function bindNativeSession({ event, clientPid, clientVersion, runtimeDir,
@@ -86,20 +109,41 @@ export async function bindNativeSession({ event, clientPid, clientVersion, runti
       const endpoint = { schemaVersion: 1, endpointId: newEndpointId(), socketPath,
         threadId: event.sessionId, cwd, clientVersion, protocolContract: PROTOCOL_CONTRACT,
         leaseUntil: new Date(now() + LEASE_MS).toISOString() };
-      const reason = await verifyReceiver(peer, endpoint);
-      if (reason !== null) return rejected(reason);
-      await writeNativeEndpoint({ runtimeDir, record: endpoint });
-      return handshake(endpoint, now);
+      const { reasonCode, servingVersion } = await verifyReceiver(peer, endpoint);
+      if (reasonCode !== null) return rejected(reasonCode);
+      // The daemon may have restarted onto a different build since the
+      // caller's claimed clientVersion was captured; persist what actually
+      // answered so the binding and its later reads reflect the serving
+      // process, not the caller's claim.
+      const verified = { ...endpoint, clientVersion: servingVersion };
+      await writeNativeEndpoint({ runtimeDir, record: verified });
+      return handshake(verified, now);
     });
   } catch (error) {
     return rejected(error?.code === "ETIMEDOUT" ? "handshake_timeout" : "handshake_failed");
   }
 }
 
+// Resolving the binding's opaque reference is the whole of the identity check:
+// the endpoint id is 128 random bits minted per bind, readNativeEndpoint
+// re-checks that the record it read carries that exact id, and no two bindings
+// can name the same record.
+//
+// The two records' clientVersion snapshots used to be compared here as well.
+// That was never identity - the id already settles that - it was a third
+// version rule, and the only one applied to a stored snapshot rather than to
+// the process now answering. It is deliberately gone. It cannot refuse
+// anything verifyReceiver does not refuse better two lines on, against the
+// version that actually answers, with the thread and cwd, before anything is
+// queued; and against the snapshot it could only ever be vacuous, because a
+// record is written solely from a serving version that already cleared
+// CODEX_QUEUE_MINIMUM. What it did do was fire on the case 0.5.0 exists to
+// support: the endpoint records what the daemon serves, the binding recorded
+// what `codex --version` printed, and a daemon that had updated under its CLI
+// was refused here on that difference alone.
 async function receiverFor(binding, runtimeDir) {
   const endpoint = await readNativeEndpoint({ runtimeDir, endpointId: binding?.opaqueEndpointRef });
-  return endpoint?.clientVersion === binding?.clientVersion
-    && await socketIsReady(endpoint?.socketPath) ? endpoint : null;
+  return endpoint !== null && await socketIsReady(endpoint.socketPath) ? endpoint : null;
 }
 
 export async function refreshNativeSession({ binding, runtimeDir, timeoutMs = 750,
@@ -109,8 +153,9 @@ export async function refreshNativeSession({ binding, runtimeDir, timeoutMs = 75
   if (endpoint === null) return rejected("handshake_failed");
   try {
     return await usingPeer(endpoint.socketPath, timeoutMs, open, async peer => {
-      const reason = await verifyReceiver(peer, endpoint);
-      return reason === null ? handshake(endpoint, now) : rejected(reason);
+      const { reasonCode, servingVersion } = await verifyReceiver(peer, endpoint);
+      return reasonCode === null
+        ? handshake({ ...endpoint, clientVersion: servingVersion }, now) : rejected(reasonCode);
     });
   } catch (error) {
     return rejected(error?.code === "ETIMEDOUT" ? "handshake_timeout" : "handshake_failed");
@@ -125,12 +170,12 @@ export async function offerMessage({ binding, message, runtimeDir, timeoutMs = 5
   if (endpoint === null) return rejected("recipient_unavailable");
   try {
     return await usingPeer(endpoint.socketPath, timeoutMs, open, async peer => {
-      const reason = await verifyReceiver(peer, endpoint);
-      if (reason !== null) return rejected(reason === "handshake_timeout" ? "transport_error"
-        : reason === "handshake_version_mismatch" ? "unsupported_client_version" : "recipient_unavailable");
+      const { reasonCode, servingVersion } = await verifyReceiver(peer, endpoint);
+      if (reasonCode !== null) return rejected(reasonCode === "handshake_timeout" ? "transport_error"
+        : reasonCode === "handshake_version_mismatch" ? "unsupported_client_version" : "recipient_unavailable");
       await addCodexQueueMessage(peer, { threadId: endpoint.threadId,
         messageId: message.messageId, text: renderText(message) });
-      return { accepted: true, transport: "codex-app-server", clientVersion: endpoint.clientVersion };
+      return { accepted: true, transport: "codex-app-server", clientVersion: servingVersion };
     });
   } catch (error) {
     if (["EPERM", "EACCES"].includes(error?.code)) return rejected("transport_permission_denied");

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

@@ -1,6 +1,6 @@
 {
   "name": "agents-can-communicate",
-  "version": "0.4.3",
+  "version": "0.5.0",
   "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.4.3",
+  "version": "0.5.0",
   "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.4.3",
+  "version": "0.5.0",
   "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.4.3",
+  "version": "0.5.0",
   "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.4.3",
+  "version": "0.5.0",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -3,7 +3,7 @@
 export { CAPABILITY_SHAPE, assertCapabilities, defineAdapter } from "./capabilities.mjs";
 export { effectiveCapabilities, validateCertification } from "./certification.mjs";
 export { NATIVE_ACTIVATION_KINDS, NATIVE_BINDING_MODES, NATIVE_PLATFORMS, NATIVE_REASON_CODES,
-  compareStableVersions, evaluateNativeEligibility, parseStableVersion,
+  compareStableVersions, evaluateNativeEligibility, evaluateVersionContract, parseStableVersion,
   validateNativeActivationPlan, validateNativeDeliveryContract, validateNativeHandshake }
   from "./native-delivery.mjs";
 export { EVENT_KINDS, NORMALIZED_EVENT_KEYS, normalizedEvent } from "./events.mjs";