agents-can-communicate 0.8.5 → 0.9.0

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

@@ -1,13 +1,17 @@
 import { createHash } from "node:crypto";
-import { execFile } from "node:child_process";
 import { constants } from "node:fs";
-import { lstat, mkdir, open, rm } from "node:fs/promises";
+import { lstat, mkdir, open, readdir, rm } from "node:fs/promises";
 import net from "node:net";
 import path from "node:path";
 
-import { decisionBody } from "@agents-can-communicate/adapter-sdk";
+import { decisionBody, isWindowsPlatform, readProcessArgs, resolveExecutable, runExecutable }
+  from "@agents-can-communicate/adapter-sdk";
 
-import { PROTOCOL_CONTRACT, RELAY_MODES, listRegistrations, readRegistration, relayDir }
+import { isAgy } from "./client-process.mjs";
+import { bindDesktop, offerDesktop, refreshDesktop } from "./desktop-delivery.mjs";
+import { isDesktopEndpointId } from "./desktop-endpoint.mjs";
+import { relayStartCommand } from "./relays.mjs";
+import { PROTOCOL_CONTRACT, RELAY_MODES, listRegistrations, readRegistration, relayDir, relayPipeName }
   from "./relay-endpoint.mjs";
 
 /**
@@ -18,19 +22,31 @@ import { PROTOCOL_CONTRACT, RELAY_MODES, listRegistrations, readRegistration, re
  */
 const TRANSPORT = "antigravity-relay";
 const defaultAlive = pid => { try { process.kill(pid, 0); return true; } catch { return false; } };
-const runDefault = (command, args, { timeout }) => new Promise(resolve => {
-  execFile(command, args, { timeout, windowsHide: true },
-    (_error, stdout, stderr) => resolve({ stdout: `${stdout ?? ""}${stderr ?? ""}` }));
-});
-const argvDefault = async pid => (await runDefault("ps", ["-o", "args=", "-p", String(pid)],
-  { timeout: 1_000 })).stdout.trim().split(/\s+/).filter(Boolean);
+// agy is found the way the platform finds it, and a .cmd starts through cmd.exe.
+const runDefault = async (command, args, { timeout }) => {
+  const file = await resolveExecutable(command) ?? command;
+  return runExecutable(file, args, { timeout }).then(
+    ({ stdout, stderr }) => ({ stdout: `${stdout ?? ""}${stderr ?? ""}` }),
+    error => ({ stdout: `${error?.stdout ?? ""}${error?.stderr ?? ""}` }));
+};
+const argvDefault = async pid => await readProcessArgs(pid, { timeoutMs: 1_000 }) ?? [];
 
 export function isPrintMode(argv) {
   return argv.some(arg => arg === "-p" || arg === "--print" || arg.startsWith("--print=")
     || arg.startsWith("-p="));
 }
 
-export async function isSocketSafe(socketPath) {
+const listPipesOfMachine = () => readdir("\\\\.\\pipe\\");
+
+/** A relay socket only this user can open; on Windows a relay pipe the machine lists. */
+export async function isSocketSafe(socketPath, { platform = process.platform,
+  listPipes = listPipesOfMachine } = {}) {
+  if (isWindowsPlatform(platform)) {
+    const name = relayPipeName(socketPath);
+    if (name === null) return false;
+    const pipes = await Promise.resolve().then(listPipes).catch(() => []);
+    return pipes.some(pipe => String(pipe).toLowerCase() === name);
+  }
   try {
     const info = await lstat(socketPath);
     return info.isSocket() && (typeof process.getuid !== "function" || info.uid === process.getuid())
@@ -63,12 +79,12 @@ const closedHandshake = (clientVersion, reasonCode) => ({ supported: false,
   clientVersion: clientVersion ?? null, protocolContract: PROTOCOL_CONTRACT, modes: [],
   opaqueEndpointRef: null, leaseUntil: null, reasonCode });
 
-async function serving(record, { timeoutMs, isAlive, clientPid }) {
+async function serving(record, { timeoutMs, isAlive, clientPid, platform = process.platform }) {
   if (record === null || record.protocolContract !== PROTOCOL_CONTRACT) return "native_session_unavailable";
   if (clientPid !== undefined && record.agyPid !== clientPid) return "native_session_unavailable";
   if (!isAlive(record.agyPid) || !isAlive(record.relayPid)) return "native_session_unavailable";
   if (Date.parse(record.leaseUntil) <= Date.now()) return "native_session_unavailable";
-  if (!await isSocketSafe(record.socketPath)) return "native_session_unavailable";
+  if (!await isSocketSafe(record.socketPath, { platform })) return "native_session_unavailable";
   try {
     const pong = await askRelay(record.socketPath, { nonce: record.nonce, ping: true }, timeoutMs);
     return pong?.accepted === true && pong.ping === true ? null : "handshake_failed";
@@ -81,7 +97,8 @@ const handshake = record => ({ supported: true, clientVersion: record.clientVers
   protocolContract: PROTOCOL_CONTRACT, modes: [...RELAY_MODES],
   opaqueEndpointRef: record.endpointId, leaseUntil: record.leaseUntil, reasonCode: null });
 
-export async function probeNativeDelivery({ timeoutMs = 750, run = runDefault } = {}) {
+export async function probeNativeDelivery({ timeoutMs = 750, run = runDefault,
+  platform = process.platform } = {}) {
   const unsupported = (reasonCode, clientVersion = null) => ({ supported: false, clientVersion,
     protocolContract: PROTOCOL_CONTRACT, executableFingerprint: null, modes: [], reasonCode });
   try {
@@ -103,18 +120,22 @@ export function planNativeActivation() {
 }
 
 export async function bindNativeSession({ event, clientPid, clientVersion, runtimeDir,
-  timeoutMs = 750, isAlive = defaultAlive } = {}) {
+  timeoutMs = 750, isAlive = defaultAlive, platform = process.platform, desktop = bindDesktop } = {}) {
   if (!Number.isInteger(clientPid) || clientPid <= 0) return closedHandshake(clientVersion, "client_process_unknown");
-  const candidates = (await listRegistrations({ runtimeDir }))
+  // The desktop app's own language server: no relay, the server is the endpoint.
+  const served = await desktop({ event, clientPid, clientVersion, runtimeDir, timeoutMs });
+  if (served !== null) return served;
+  const candidates = (await listRegistrations({ runtimeDir, platform }))
     .filter(record => record.conversationId === event?.sessionId);
   for (const record of candidates) {
-    if (await serving(record, { timeoutMs, isAlive, clientPid }) === null) return handshake(record);
+    if (await serving(record, { timeoutMs, isAlive, clientPid, platform }) === null) return handshake(record);
   }
   return closedHandshake(clientVersion, "native_session_unavailable");
 }
 
 export async function refreshNativeSession({ binding, runtimeDir, timeoutMs = 750,
   isAlive = defaultAlive } = {}) {
+  if (isDesktopEndpointId(binding?.opaqueEndpointRef)) return refreshDesktop({ binding, runtimeDir, timeoutMs });
   const record = await readRegistration({ runtimeDir, endpointId: binding?.opaqueEndpointRef });
   const reasonCode = await serving(record, { timeoutMs, isAlive });
   return reasonCode === null ? handshake(record) : closedHandshake(binding?.clientVersion, reasonCode);
@@ -124,6 +145,9 @@ const SAFE_CODES = new Map([["recipient_unavailable", "recipient_unavailable"],
   ["transport_rejected", "transport_rejected"], ["bad_nonce", "recipient_unavailable"]]);
 
 export async function offerMessage({ binding, message, runtimeDir, timeoutMs = 8_000 } = {}) {
+  if (isDesktopEndpointId(binding?.opaqueEndpointRef)) {
+    return offerDesktop({ binding, message, runtimeDir, timeoutMs });
+  }
   const rejected = safeErrorCode => ({ accepted: false, transport: TRANSPORT,
     clientVersion: binding?.clientVersion ?? null, safeErrorCode });
   const record = await readRegistration({ runtimeDir, endpointId: binding?.opaqueEndpointRef });
@@ -146,9 +170,8 @@ export async function offerMessage({ binding, message, runtimeDir, timeoutMs = 8
 }
 
 const ASK_LIMIT = 3;
-const HINT = home => "ACC: live delivery is on but not running in this conversation. To let "
-  + `peers reach you while idle, run once: sh "${path.join(home, ".gemini", "config", "acc",
-    "acc-relay.sh")}" start`;
+const HINT = (home, platform) => "ACC: live delivery is on but not running in this conversation. "
+  + `To let peers reach you while idle, run once: ${relayStartCommand(home, platform)}`;
 
 // Each ask is its own file, created exclusively. A counter read and then
 // rewritten lets overlapping calls all observe the same count and each return
@@ -191,15 +214,20 @@ async function relayAlreadyServing({ runtimeDir, conversationId, clientPid, isAl
 }
 
 export async function nativeActivationHint({ event, nativeBinding, runtimeDir, clientPid, env,
-  argvOf = argvDefault, isAlive = defaultAlive }) {
+  argvOf = argvDefault, isAlive = defaultAlive, platform = process.platform }) {
   // Only a degraded binding can be helped by starting a relay: "off" means the
   // live policy is off, "unsupported" that the contract does not admit this
   // client, and "active" that a relay already serves it. Those calls spend
   // none of the asks recorded below.
   if (nativeBinding?.state !== "degraded") return null;
-  const home = env?.HOME;
+  // Windows keeps the profile in USERPROFILE; HOME is set only by Git Bash.
+  const home = isWindowsPlatform(platform) ? env?.USERPROFILE ?? env?.HOME : env?.HOME;
   if (typeof event?.sessionId !== "string" || typeof home !== "string" || home === "") return null;
-  if (!Number.isInteger(clientPid) || isPrintMode(await argvOf(clientPid).catch(() => []))) return null;
+  if (!Number.isInteger(clientPid)) return null;
+  // The relay is Antigravity CLI's: the desktop app runs no agy, and its
+  // sandbox lets no relay start. A print-mode agy ends with its turn.
+  const argv = await argvOf(clientPid).catch(() => []);
+  if (!isAgy(argv) || isPrintMode(argv)) return null;
   // The runner asks only when its own handshake failed. A relay can still be
   // serving under a stale degraded binding; telling the agent to start it again
   // would be wrong, and the check does not spend an ask.
@@ -212,5 +240,14 @@ export async function nativeActivationHint({ event, nativeBinding, runtimeDir, c
   // the number now; release gives it back when the runner does not deliver.
   const slot = await claimAsk(asked, marker);
   if (slot === null) return null;
-  return { line: HINT(home), release: () => releaseAsk(slot) };
+  let line;
+  try {
+    line = HINT(home, platform);
+  } catch {
+    // A profile path no shell reads alike gets no command to run; the message
+    // still arrives on the next turn.
+    await releaseAsk(slot);
+    return null;
+  }
+  return { line, release: () => releaseAsk(slot) };
 }

package/node_modules/@agents-can-communicate/adapter-antigravity/src/relay-endpoint.mjs

@@ -1,8 +1,9 @@
 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 { closedTo, isWindowsPlatform, openRegularNoFollow } from "@agents-can-communicate/adapter-sdk";
+
 /**
  * Where a running relay is found, and what it may be trusted with.
  *
@@ -11,6 +12,10 @@ import path from "node:path";
  * session endpoint - the language-server address and the CSRF token - is never
  * part of it. A key outside the closed list below is refused, so a mistake that
  * tried to persist one fails loudly instead of quietly writing a credential.
+ *
+ * On Windows the relay listens on a named pipe, `\\.\pipe\acc-relay-<32 hex>`,
+ * and the record and its directory carry no mode bits: the profile's ACL keeps
+ * them to this user.
  */
 export const PROTOCOL_CONTRACT = "antigravity-agentapi-relay-v1";
 export const RELAY_MODES = Object.freeze(["livePush", "idleWake", "busyQueue"]);
@@ -23,42 +28,46 @@ const NONCE = /^[a-f0-9]{64}$/;
 const VERSION = /^\d+\.\d+\.\d+$/;
 const LEASE = /^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d{3}Z$/;
 const MAX_BYTES = 4_096;
+const RELAY_PIPE = /^\\\\\.\\pipe\\(acc-relay-[0-9a-f]{32})$/;
 const own = info => typeof process.getuid !== "function" || info.uid === process.getuid();
 const pid = value => Number.isInteger(value) && value > 0;
 const invalid = () => new Error("invalid Antigravity relay registration");
 
 export const relayDir = runtimeDir => path.join(runtimeDir, "native", "antigravity");
 export const newRelayId = () => `antigravity_relay_${randomBytes(16).toString("hex")}`;
+/** The pipe name a relay pipe path carries, or null. */
+export const relayPipeName = value => (typeof value === "string" ? RELAY_PIPE.exec(value)?.[1] ?? null : null);
+const socketPathValid = (value, platform) => (isWindowsPlatform(platform) ? relayPipeName(value) !== null
+  : typeof value === "string" && path.isAbsolute(value) && Buffer.byteLength(value) < 104);
 
-export function validRegistration(record) {
+export function validRegistration(record, { platform = process.platform } = {}) {
   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 && RELAY_ID.test(record.endpointId)
     && CONVERSATION.test(record.conversationId) && pid(record.agyPid) && pid(record.relayPid)
-    && typeof record.socketPath === "string" && path.isAbsolute(record.socketPath)
-    && Buffer.byteLength(record.socketPath) < 104 && NONCE.test(record.nonce)
+    && socketPathValid(record.socketPath, platform) && NONCE.test(record.nonce)
     && VERSION.test(record.clientVersion) && record.protocolContract === PROTOCOL_CONTRACT
     && Array.isArray(record.modes) && record.modes.every(mode => RELAY_MODES.includes(mode))
     && typeof record.leaseUntil === "string" && LEASE.test(record.leaseUntil)
     && Number.isFinite(Date.parse(record.leaseUntil));
 }
 
-async function directory(runtimeDir, create = false) {
+async function directory(runtimeDir, create = false, platform = process.platform) {
   if (typeof runtimeDir !== "string" || !path.isAbsolute(runtimeDir)) throw invalid();
   const dir = relayDir(await realpath(runtimeDir));
   if (create) await mkdir(dir, { recursive: true, mode: 0o700 });
   const info = await lstat(dir);
-  if (!info.isDirectory() || info.isSymbolicLink() || !own(info) || (info.mode & 0o077) !== 0) {
+  if (!info.isDirectory() || info.isSymbolicLink() || !own(info) || !closedTo(info, 0o077, { platform })) {
     throw invalid();
   }
   return dir;
 }
 
-export async function writeRegistration({ runtimeDir, record }) {
-  if (!validRegistration(record)) throw invalid();
+export async function writeRegistration({ runtimeDir, record, platform = process.platform }) {
+  if (!validRegistration(record, { platform })) throw invalid();
   const text = `${JSON.stringify(record)}\n`;
   if (Buffer.byteLength(text) > MAX_BYTES) throw invalid();
-  const dir = await directory(runtimeDir, true);
+  const dir = await directory(runtimeDir, true, platform);
   const file = path.join(dir, `${record.endpointId}.json`);
   const temporary = path.join(dir, `.${record.endpointId}.${randomBytes(8).toString("hex")}.tmp`);
   let handle;
@@ -74,17 +83,18 @@ export async function writeRegistration({ runtimeDir, record }) {
   return file;
 }
 
-export async function readRegistration({ runtimeDir, endpointId }) {
+export async function readRegistration({ runtimeDir, endpointId, platform = process.platform }) {
   if (typeof endpointId !== "string" || !RELAY_ID.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 dir = await directory(runtimeDir, false, platform);
+    handle = await openRegularNoFollow(path.join(dir, `${endpointId}.json`), undefined, { platform });
     const info = await handle.stat();
-    if (!info.isFile() || !own(info) || info.size > MAX_BYTES || (info.mode & 0o077) !== 0) return null;
+    if (!info.isFile() || !own(info) || info.size > MAX_BYTES || !closedTo(info, 0o077, { platform })) {
+      return null;
+    }
     const record = JSON.parse(await handle.readFile("utf8"));
-    return validRegistration(record) && record.endpointId === endpointId ? record : null;
+    return validRegistration(record, { platform }) && record.endpointId === endpointId ? record : null;
   } catch {
     return null;
   } finally {
@@ -92,25 +102,25 @@ export async function readRegistration({ runtimeDir, endpointId }) {
   }
 }
 
-export async function listRegistrations({ runtimeDir }) {
+export async function listRegistrations({ runtimeDir, platform = process.platform }) {
   let names;
   try {
-    names = await readdir(await directory(runtimeDir));
+    names = await readdir(await directory(runtimeDir, false, platform));
   } catch {
     return [];
   }
   const found = [];
   for (const name of names) {
     if (!name.endsWith(".json")) continue;
-    const record = await readRegistration({ runtimeDir, endpointId: name.slice(0, -5) });
+    const record = await readRegistration({ runtimeDir, endpointId: name.slice(0, -5), platform });
     if (record !== null) found.push(record);
   }
   return found;
 }
 
-export async function removeRegistration({ runtimeDir, endpointId }) {
+export async function removeRegistration({ runtimeDir, endpointId, platform = process.platform }) {
   if (typeof endpointId !== "string" || !RELAY_ID.test(endpointId)) return;
   try {
-    await rm(path.join(await directory(runtimeDir), `${endpointId}.json`), { force: true });
+    await rm(path.join(await directory(runtimeDir, false, platform), `${endpointId}.json`), { force: true });
   } catch { /* retirement is already decided; cleanup is best effort */ }
 }

package/node_modules/@agents-can-communicate/adapter-antigravity/src/relay-start.mjs

@@ -86,7 +86,8 @@ export function spawnRelay({ command, args, env, payload, readyMs = 10_000, spaw
   return new Promise(resolve => {
     let child;
     try {
-      child = spawn(command, args, { env, detached: true, stdio: ["pipe", "pipe", "ignore"] });
+      child = spawn(command, args, { env, detached: true, windowsHide: true,
+        stdio: ["pipe", "pipe", "ignore"] });
     } catch {
       resolve({ ok: false, reason: "could not start" });
       return;

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

@@ -3,7 +3,7 @@ import { chmodSync, existsSync, mkdirSync, unlinkSync } from "node:fs";
 import net from "node:net";
 import path from "node:path";
 
-import { channelSocketDirectory } from "@agents-can-communicate/adapter-sdk";
+import { channelSocketDirectory, isWindowsPlatform } from "@agents-can-communicate/adapter-sdk";
 
 import { PROTOCOL_CONTRACT, RELAY_MODES, newRelayId, removeRegistration, writeRegistration }
   from "./relay-endpoint.mjs";
@@ -52,13 +52,17 @@ export function createRelay({ runtimeDir, socketDir = channelSocketDirectory(),
   leaseMs = 120_000,
   renewMs = 40_000, pidCheckMs = 5_000, probeMs = 60_000, lifetimeMs = 86_400_000,
   budgetBytes = 6_000, refreshBinding = null, onExit = () => {}, observe = () => {},
-  now = Date.now }) {
+  now = Date.now, platform = process.platform }) {
   // The binary picks the id first, so its log file can be named before the
   // relay exists; tests let the relay choose.
   const endpointId = requestedId ?? newRelayId();
   const nonce = randomBytes(32).toString("hex");
-  const socketPath = path.join(socketDir, `r${randomBytes(6).toString("hex")}.sock`);
-  if (Buffer.byteLength(socketPath) >= 104) throw new Error("relay socket path is too long");
+  // Windows: a named pipe whose 128 random bits only the private registration
+  // records; libuv creates the first instance, so no one can take the name first.
+  const windows = isWindowsPlatform(platform);
+  const socketPath = windows ? `\\\\.\\pipe\\acc-relay-${randomBytes(16).toString("hex")}`
+    : path.join(socketDir, `r${randomBytes(6).toString("hex")}.sock`);
+  if (!windows && Buffer.byteLength(socketPath) >= 104) throw new Error("relay socket path is too long");
   const seen = new Set();
   const connections = new Set();
   const timers = [];
@@ -140,7 +144,7 @@ export function createRelay({ runtimeDir, socketDir = channelSocketDirectory(),
   async function renew() {
     if (closed) return;
     const next = record();
-    await writeRegistration({ runtimeDir, record: next });
+    await writeRegistration({ runtimeDir, record: next, platform });
     if (refreshBinding !== null) await Promise.resolve(refreshBinding(next.leaseUntil)).catch(() => {});
   }
 
@@ -150,8 +154,9 @@ export function createRelay({ runtimeDir, socketDir = channelSocketDirectory(),
     for (const timer of timers) clearInterval(timer);
     for (const socket of connections) socket.destroy();
     if (server !== null) await new Promise(resolve => server.close(() => resolve()));
-    try { if (existsSync(socketPath)) unlinkSync(socketPath); } catch { /* already gone */ }
-    await removeRegistration({ runtimeDir, endpointId });
+    // A pipe goes with its server; a socket file stays behind until removed.
+    try { if (!windows && existsSync(socketPath)) unlinkSync(socketPath); } catch { /* already gone */ }
+    await removeRegistration({ runtimeDir, endpointId, platform });
     observe({ event: "relay_closed", reasonCode: reason });
     onExit(reason);
   }
@@ -163,18 +168,21 @@ export function createRelay({ runtimeDir, socketDir = channelSocketDirectory(),
   }
 
   async function listen() {
-    mkdirSync(socketDir, { recursive: true, mode: 0o700 });
-    chmodSync(socketDir, 0o700);
-    if (existsSync(socketPath)) throw new Error("relay socket already exists");
+    if (!windows) {
+      mkdirSync(socketDir, { recursive: true, mode: 0o700 });
+      chmodSync(socketDir, 0o700);
+      if (existsSync(socketPath)) throw new Error("relay socket already exists");
+    }
     server = net.createServer(handleConnection);
     await new Promise((resolve, reject) => {
       server.once("error", reject);
+      if (windows) { server.listen(socketPath, resolve); return; }
       const previous = process.umask(0o177);
       server.listen(socketPath, () => { process.umask(previous); resolve(); });
     });
-    chmodSync(socketPath, 0o600);
+    if (!windows) chmodSync(socketPath, 0o600);
     const first = record();
-    await writeRegistration({ runtimeDir, record: first });
+    await writeRegistration({ runtimeDir, record: first, platform });
     const started = now();
     every(renewMs, renew);
     every(pidCheckMs, () => { if (!isAlive(agyPid)) return close("client_exited"); });

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

@@ -1,7 +1,9 @@
-import { execFile } from "node:child_process";
 import { readdir, rm } from "node:fs/promises";
 import path from "node:path";
 
+import { isWindowsPlatform, readProcessArgs, shellQuote, windowsHookCommand }
+  from "@agents-can-communicate/adapter-sdk";
+
 import { listRegistrations, relayDir, removeRegistration } from "./relay-endpoint.mjs";
 
 /**
@@ -16,10 +18,22 @@ import { listRegistrations, relayDir, removeRegistration } from "./relay-endpoin
 const RELAY_MARK = "acc-antigravity-relay";
 const RELAY_LOG = /^antigravity_relay_[a-f0-9]{32}\.log$/;
 const defaultAlive = pid => { try { process.kill(pid, 0); return true; } catch { return false; } };
-const psArgv = pid => new Promise(resolve => execFile("ps", ["-o", "args=", "-p", String(pid)],
-  { timeout: 1_000 }, (_error, out) => resolve(String(out ?? "").trim().split(/\s+/).filter(Boolean))));
+const psArgv = async pid => await readProcessArgs(pid, { timeoutMs: 1_000 }) ?? [];
+
+// Windows runs no `sh`: there the shim is a Node script, started with node on a
+// forward-slash path that PowerShell, cmd and Git Bash read alike.
+export const relayShimName = platform => (isWindowsPlatform(platform) ? "acc-relay.mjs" : "acc-relay.sh");
+
+// The path in the platform's own spelling, for the command the agent is told to
+// run. The file itself is written where this host spells the same path.
+export const relayShimPath = (home, platform = process.platform) => (isWindowsPlatform(platform)
+  ? path.win32.join(home, ".gemini", "config", "acc", relayShimName(platform))
+  : path.posix.join(home, ".gemini", "config", "acc", relayShimName(platform)));
 
-export const relayShimPath = home => path.join(home, ".gemini", "config", "acc", "acc-relay.sh");
+/** The command the agent runs once per conversation to start live delivery. */
+export const relayStartCommand = (home, platform = process.platform) => (isWindowsPlatform(platform)
+  ? windowsHookCommand("portable", { node: "node", shim: relayShimPath(home, platform), args: ["start"] })
+  : `sh ${shellQuote(relayShimPath(home, platform))} start`);
 
 async function workspaceDirs(dataHome, list = readdir) {
   if (typeof dataHome !== "string" || dataHome === "") return [];

package/node_modules/@agents-can-communicate/adapter-claude-code/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/adapter-claude-code",
-  "version": "0.8.5",
+  "version": "0.9.0",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -6,6 +6,7 @@ import { denyOutcome, injectOutcome, injectStartOwnerOutcome, normalizeClaudeHoo
 import { MIN_VERSION, PROTOCOL_CONTRACT, bindNativeSession, offerMessage, planNativeActivation,
   probeNativeDelivery, refreshNativeSession, retireNativeSession } from "./inbox-delivery.mjs";
 import { observedInboxDirectories } from "./inbox-observed-directories.mjs";
+import { claudeConfigDir, readSessionRecord } from "./inbox-registry.mjs";
 import { inboxSocketDirectories } from "./inbox-socket-directories.mjs";
 import { planClaudeInstall, detectClaude, installClaudePlugin, uninstallClaudePlugin } from "./install.mjs";
 
@@ -36,6 +37,11 @@ export function createClaudeCodeAdapter() {
     // decide whether the client is on this machine, so it has to be the
     // real command rather than the adapter id: `2.1.233 (Claude Code)`.
     client: { command: "claude", certificationName: "claude-code", versionArgs: ["--version"] },
+    // The build the session runs. Claude Code updates itself under running
+    // sessions and Claude.app runs a build of its own, so the `claude` on PATH
+    // can name another version; each session's registry record names its own.
+    clientVersionOf: async ({ pid, env }) => (await readSessionRecord({
+      configDir: claudeConfigDir(env), clientPid: pid }))?.version ?? null,
     certification,
     deliveryFallback: CLAUDE_DELIVERY_FALLBACK,
     capabilities: {