agents-can-communicate 0.7.1 → 0.8.1

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 }) {

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

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

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

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

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

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

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

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

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

@@ -4,7 +4,7 @@ import { AccError, EXIT } from "@agents-can-communicate/protocol";
 // so the four cannot drift: a consumer that has to ask which adapter produced an
 // event is a consumer that will eventually get it wrong.
 export const NORMALIZED_EVENT_KEYS = Object.freeze(["kind", "sessionId", "cwd", "model",
-  "parentSessionId", "tool", "targets"]);
+  "parentSessionId", "tool", "targets", "permissionMode", "endReason"]);
 
 export const EVENT_KINDS = Object.freeze(["sessionStart", "sessionEnd", "heartbeat",
   "beforeTurn", "beforeTool", "afterTool", "turnEnd", "childStart", "childEnd", "other"]);
@@ -34,7 +34,7 @@ export function normalizedEvent(fields) {
     }
   }
   const { kind, sessionId, cwd, model = null, parentSessionId = null, tool = null,
-    targets = [] } = fields;
+    targets = [], permissionMode = null, endReason = null } = fields;
 
   if (!EVENT_KINDS.includes(kind)) data("unknown normalised event kind", { kind });
   if (typeof sessionId !== "string" || sessionId === "") {
@@ -50,6 +50,19 @@ export function normalizedEvent(fields) {
     }
   }
 
+  // The client's own name for the session's permission mode, when its hook
+  // reports one. Only a native binding reads it, to tell a sender whether the
+  // client will hold a wake for approval.
+  if (permissionMode !== null && (typeof permissionMode !== "string" || permissionMode === "")) {
+    data("normalised event permission mode must be a non-empty string", { kind });
+  }
+
+  // Why the client ended the session, in its own words, when it says. A sender
+  // is told a conversation was cleared rather than that its peer vanished.
+  if (endReason !== null && (typeof endReason !== "string" || endReason === "")) {
+    data("normalised event end reason must be a non-empty string", { kind });
+  }
+
   return Object.freeze({ kind, sessionId, cwd, model, parentSessionId, tool,
-    targets: Object.freeze([...targets]) });
+    targets: Object.freeze([...targets]), permissionMode, endReason });
 }

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

@@ -58,8 +58,6 @@ const ownBinary = name => {
 };
 
 export const defaultRunner = () => ownBinary("acc-hook.mjs");
-export const defaultBootstrap = () => ownBinary("acc-bootstrap.mjs");
-export const defaultChannel = () => ownBinary("acc-claude-channel.mjs");
 export const defaultAntigravityRelay = () => ownBinary("acc-antigravity-relay.mjs");
 
 export const runnerExists = async runner => {
@@ -199,7 +197,10 @@ export async function writeCliShim({ dir, cli = defaultCli(), node = process.exe
  * created, and a recognised path is not a reason to delete it.
  */
 export async function removeInstalledTree(target, keep = []) {
-  if (keep.includes(target)) return false;
+  // A kept tree holds someone's own work. Removing a directory inside it, or one
+  // that contains it, would delete that work as surely as removing it.
+  const within = (inner, outer) => inner === outer || inner.startsWith(`${outer}${path.sep}`);
+  if (keep.some(kept => within(target, kept) || within(kept, target))) return false;
   try {
     await lstat(target);
   } catch (error) {

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

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

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

@@ -1,6 +1,6 @@
 import path from "node:path";
 
-import { COMMAND_NAME, IDENTIFIER, NATIVE_ACTIVATION_KINDS, SHELL_SOURCE, assertReasonCode,
+import { IDENTIFIER, NATIVE_ACTIVATION_KINDS, SHELL_SOURCE, assertReasonCode,
   closed, deepFreeze, isPlainObject, isText, usage } from "./native-vocabulary.mjs";
 
 // A native activation plan is what an adapter hands the installer: closed
@@ -27,19 +27,9 @@ function validateMechanism(mechanism, index) {
     usage(`${label} kind must be one of ${NATIVE_ACTIVATION_KINDS.join(", ")}`);
   }
   if (mechanism.kind === "shell-bootstrap") {
-    closed(mechanism, ["kind", "command", "realExecutable", "prefixArgs"], label);
-    if (!isText(mechanism.command) || !COMMAND_NAME.test(mechanism.command)) {
-      usage(`${label} command must be a bare command name`);
-    }
-    if (!isText(mechanism.realExecutable) || !path.isAbsolute(mechanism.realExecutable)) {
-      usage(`${label} realExecutable must be an absolute path`);
-    }
-    if (!Array.isArray(mechanism.prefixArgs) || mechanism.prefixArgs.some(arg => !isText(arg)
-      || SHELL_SOURCE.test(arg))) {
-      usage(`${label} prefixArgs must be plain argument strings, never shell source`);
-    }
-    return { kind: mechanism.kind, command: mechanism.command,
-      realExecutable: mechanism.realExecutable, prefixArgs: [...mechanism.prefixArgs] };
+    // ACC 0.7.x put a `claude` shim on PATH this way. Install records of it are
+    // still read so it can be retired; a plan can no longer create one.
+    usage(`${label}: shell-bootstrap activation was removed; no adapter may plan one`);
   }
   if (mechanism.kind === "native-config") {
     closed(mechanism, ["kind", "artifactIds"], label);