agents-can-communicate 0.8.4 → 0.9.0

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

@@ -0,0 +1,110 @@
+import { decisionBody } from "@agents-can-communicate/adapter-sdk";
+
+import { createAgentApi } from "./agentapi.mjs";
+import { DESKTOP_MODES, DESKTOP_PROTOCOL, httpPort, listDesktopEndpoints, newDesktopEndpointId,
+  readDesktopEndpoint, readDesktopServer, removeDesktopEndpoint, writeDesktopEndpoint }
+  from "./desktop-endpoint.mjs";
+import { renderMessage } from "./relay.mjs";
+
+/**
+ * Live delivery into an Antigravity 2.0 desktop conversation.
+ *
+ * No relay and nothing for the agent to run: the desktop's language server is
+ * the client process ACC's own hook ran under, and its command line carries the
+ * endpoint. Each bind finds the port that serves `agentapi` and proves it
+ * answers for this conversation; each offer reads the token again from the
+ * same, still-running server and hands it to one `agentapi` child in that
+ * child's environment, exactly as the relay does for Antigravity CLI.
+ */
+export const DESKTOP_TRANSPORT = "antigravity-desktop";
+const LEASE_MS = 120_000;
+const CODES = new Map([["recipient_unavailable", "recipient_unavailable"],
+  ["transport_rejected", "transport_rejected"]]);
+
+const closed = (clientVersion, reasonCode) => ({ supported: false, clientVersion: clientVersion ?? null,
+  protocolContract: DESKTOP_PROTOCOL, modes: [], opaqueEndpointRef: null, leaseUntil: null, reasonCode });
+const handshake = record => ({ supported: true, clientVersion: record.clientVersion,
+  protocolContract: DESKTOP_PROTOCOL, modes: [...DESKTOP_MODES], opaqueEndpointRef: record.endpointId,
+  leaseUntil: record.leaseUntil, reasonCode: null });
+
+const apiFor = ({ server, port, conversationId, runAgentApi, timeoutMs }) => createAgentApi({
+  endpoint: { lsAddress: `127.0.0.1:${port}`, csrfToken: server.token, conversationId },
+  command: server.executable, timeoutMs, ...(runAgentApi ? { run: runAgentApi } : {}) });
+
+// The server the record names, if it is the same process still: same pid,
+// same start time, still the desktop language server.
+async function sameServer(record, readServer) {
+  const server = await readServer(record.serverPid);
+  return server !== null && server.startedAt === record.serverStartedAt ? server : null;
+}
+
+/**
+ * The desktop bind, or null when the client process is not the desktop's
+ * language server - the caller then binds Antigravity CLI's relay instead.
+ */
+export async function bindDesktop({ event, clientPid, clientVersion, runtimeDir, timeoutMs = 750,
+  now = Date.now, readServer = readDesktopServer, findPort = httpPort, runAgentApi } = {}) {
+  const server = await readServer(clientPid);
+  if (server === null) return null;
+  const version = server.version ?? clientVersion;
+  if (typeof version !== "string" || !/^\d+\.\d+\.\d+$/.test(version)) {
+    return closed(clientVersion, "version_unavailable");
+  }
+  const conversationId = event?.sessionId;
+  if (typeof conversationId !== "string" || !/^[A-Za-z0-9-]{8,128}$/.test(conversationId)) {
+    return closed(version, "handshake_failed");
+  }
+  const port = await findPort(clientPid);
+  if (port === null) return closed(version, "native_endpoint_unavailable");
+  const answer = await apiFor({ server, port, conversationId, runAgentApi, timeoutMs })
+    .conversationMetadata();
+  if (!answer.ok) {
+    return closed(version, answer.reasonCode === "recipient_unavailable"
+      ? "native_session_unavailable" : "handshake_failed");
+  }
+  // One record per conversation: the one this bind proved.
+  for (const old of await listDesktopEndpoints({ runtimeDir })) {
+    if (old.conversationId === conversationId) await removeDesktopEndpoint({ runtimeDir, endpointId: old.endpointId });
+  }
+  const record = { schemaVersion: 1, endpointId: newDesktopEndpointId(), conversationId,
+    serverPid: clientPid, serverStartedAt: server.startedAt, port, clientVersion: version,
+    protocolContract: DESKTOP_PROTOCOL, modes: [...DESKTOP_MODES],
+    leaseUntil: new Date(now() + LEASE_MS).toISOString() };
+  await writeDesktopEndpoint({ runtimeDir, record });
+  return handshake(record);
+}
+
+/** The router's re-check before an offer on an expired lease. */
+export async function refreshDesktop({ binding, runtimeDir, timeoutMs = 750, now = Date.now,
+  readServer = readDesktopServer, runAgentApi } = {}) {
+  const record = await readDesktopEndpoint({ runtimeDir, endpointId: binding?.opaqueEndpointRef });
+  if (record === null) return closed(binding?.clientVersion, "native_session_unavailable");
+  const server = await sameServer(record, readServer);
+  if (server === null) return closed(record.clientVersion, "native_session_unavailable");
+  const answer = await apiFor({ server, port: record.port, conversationId: record.conversationId,
+    runAgentApi, timeoutMs }).conversationMetadata();
+  if (!answer.ok) return closed(record.clientVersion, "handshake_failed");
+  const renewed = { ...record, leaseUntil: new Date(now() + LEASE_MS).toISOString() };
+  await writeDesktopEndpoint({ runtimeDir, record: renewed });
+  return handshake(renewed);
+}
+
+/** One fenced ACC message into the conversation, rendered here, never by the sender. */
+export async function offerDesktop({ binding, message, runtimeDir, timeoutMs = 8_000, now = Date.now,
+  readServer = readDesktopServer, runAgentApi, budgetBytes = 6_000 } = {}) {
+  const rejected = safeErrorCode => ({ accepted: false, transport: DESKTOP_TRANSPORT,
+    clientVersion: binding?.clientVersion ?? null, safeErrorCode });
+  const record = await readDesktopEndpoint({ runtimeDir, endpointId: binding?.opaqueEndpointRef });
+  if (record === null || Date.parse(record.leaseUntil) <= now()) return rejected("recipient_unavailable");
+  const server = await sameServer(record, readServer);
+  if (server === null) return rejected("recipient_unavailable");
+  const text = renderMessage({ messageId: message.messageId, kind: message.kind,
+    subject: message.subject ?? "", body: decisionBody(message),
+    ...(typeof message.inReplyTo === "string" ? { inReplyTo: message.inReplyTo } : {}),
+    ...(typeof message.fromParticipantId === "string" ? { fromParticipantId: message.fromParticipantId } : {}) },
+  { budgetBytes });
+  const answer = await apiFor({ server, port: record.port, conversationId: record.conversationId,
+    runAgentApi, timeoutMs }).sendMessage(text);
+  return answer.ok ? { accepted: true, transport: DESKTOP_TRANSPORT, clientVersion: record.clientVersion }
+    : rejected(CODES.get(answer.reasonCode) ?? "transport_error");
+}

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

@@ -0,0 +1,203 @@
+import { execFile } from "node:child_process";
+import { randomBytes } from "node:crypto";
+import { constants } from "node:fs";
+import { access, lstat, mkdir, open, readdir, realpath, rename, rm } from "node:fs/promises";
+import http from "node:http";
+import path from "node:path";
+
+import { closedTo, openRegularNoFollow } from "@agents-can-communicate/adapter-sdk";
+
+import { desktopServer, flagValue } from "./client-process.mjs";
+
+/**
+ * Where a desktop conversation's live endpoint is, and how it is reached.
+ *
+ * Antigravity 2.0 serves every conversation from one language server, which
+ * takes its CSRF token on its command line. ACC reads that command line when it
+ * binds and again each time it delivers, from the one process its own hook ran
+ * under, and never writes the token anywhere: the record below holds the
+ * server's pid, its start time - so a reused pid is not mistaken for it - and
+ * the loopback port that answered, nothing that would let anyone drive it.
+ */
+export const DESKTOP_PROTOCOL = "antigravity-desktop-agentapi-v1";
+export const DESKTOP_MODES = Object.freeze(["livePush", "idleWake", "busyQueue"]);
+
+const KEYS = ["schemaVersion", "endpointId", "conversationId", "serverPid", "serverStartedAt",
+  "port", "clientVersion", "protocolContract", "modes", "leaseUntil"];
+const ENDPOINT_ID = /^antigravity_desktop_[a-f0-9]{32}$/;
+const CONVERSATION = /^[A-Za-z0-9-]{8,128}$/;
+const VERSION = /^\d+\.\d+\.\d+$/;
+const LEASE = /^\d{4}-\d\d-\d\dT\d\d:\d\d:\d\d\.\d{3}Z$/;
+// `ps -o lstart`: "Sun Oct  4 22:55:53 2026", always 24 characters.
+const STARTED = /^[A-Z][a-z]{2} [A-Z][a-z]{2} [ \d]\d \d\d:\d\d:\d\d \d{4}$/;
+const MAX_BYTES = 4_096;
+const own = info => typeof process.getuid !== "function" || info.uid === process.getuid();
+const isPid = value => Number.isInteger(value) && value > 0;
+const invalid = () => new Error("invalid Antigravity desktop endpoint");
+
+export const desktopDir = runtimeDir => path.join(runtimeDir, "native", "antigravity-desktop");
+export const newDesktopEndpointId = () => `antigravity_desktop_${randomBytes(16).toString("hex")}`;
+export const isDesktopEndpointId = value => typeof value === "string" && ENDPOINT_ID.test(value);
+
+export function validDesktopEndpoint(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_ID.test(record.endpointId)
+    && CONVERSATION.test(record.conversationId) && isPid(record.serverPid)
+    && typeof record.serverStartedAt === "string" && STARTED.test(record.serverStartedAt)
+    && Number.isInteger(record.port) && record.port > 0 && record.port < 65_536
+    && VERSION.test(record.clientVersion) && record.protocolContract === DESKTOP_PROTOCOL
+    && Array.isArray(record.modes) && record.modes.every(mode => DESKTOP_MODES.includes(mode))
+    && typeof record.leaseUntil === "string" && LEASE.test(record.leaseUntil)
+    && Number.isFinite(Date.parse(record.leaseUntil));
+}
+
+async function directory(runtimeDir, create = false) {
+  if (typeof runtimeDir !== "string" || !path.isAbsolute(runtimeDir)) throw invalid();
+  const dir = desktopDir(await realpath(runtimeDir));
+  if (create) await mkdir(dir, { recursive: true, mode: 0o700 });
+  const info = await lstat(dir);
+  if (!info.isDirectory() || info.isSymbolicLink() || !own(info) || !closedTo(info, 0o077)) throw invalid();
+  return dir;
+}
+
+export async function writeDesktopEndpoint({ runtimeDir, record }) {
+  if (!validDesktopEndpoint(record)) 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);
+  }
+  return file;
+}
+
+export async function readDesktopEndpoint({ runtimeDir, endpointId }) {
+  if (!isDesktopEndpointId(endpointId)) return null;
+  let handle;
+  try {
+    handle = await openRegularNoFollow(path.join(await directory(runtimeDir), `${endpointId}.json`));
+    const info = await handle.stat();
+    if (!info.isFile() || !own(info) || info.size > MAX_BYTES || !closedTo(info, 0o077)) return null;
+    const record = JSON.parse(await handle.readFile("utf8"));
+    return validDesktopEndpoint(record) && record.endpointId === endpointId ? record : null;
+  } catch {
+    return null;
+  } finally {
+    await handle?.close().catch(() => null);
+  }
+}
+
+export async function listDesktopEndpoints({ runtimeDir }) {
+  let names;
+  try {
+    names = await readdir(await directory(runtimeDir));
+  } catch {
+    return [];
+  }
+  const found = [];
+  for (const name of names) {
+    if (!name.endsWith(".json")) continue;
+    const record = await readDesktopEndpoint({ runtimeDir, endpointId: name.slice(0, -5) });
+    if (record !== null) found.push(record);
+  }
+  return found;
+}
+
+export async function removeDesktopEndpoint({ runtimeDir, endpointId }) {
+  if (!isDesktopEndpointId(endpointId)) return;
+  try {
+    await rm(path.join(await directory(runtimeDir), `${endpointId}.json`), { force: true });
+  } catch { /* a stale record is refused on read; removal is best effort */ }
+}
+
+const runFile = (file, args, { timeout }) => new Promise(resolve => {
+  execFile(file, args, { timeout, killSignal: "SIGKILL", windowsHide: true, maxBuffer: 1024 * 1024 },
+    (error, stdout) => resolve({ ok: error === null, stdout: String(stdout ?? "") }));
+});
+
+/**
+ * The desktop language server running as `pid`, read from its command line
+ * now: when it started, the executable that serves `agentapi`, the version it
+ * names and its CSRF token. Null for any other process, a gone one, or a
+ * command line that carries no token. The token is returned to the caller for
+ * one `agentapi` call and is never stored.
+ */
+export async function readDesktopServer(pid, { run = runFile, timeoutMs = 1_000,
+  platform = process.platform } = {}) {
+  // Read through POSIX ps; a Windows desktop build is uncaptured.
+  if (!isPid(pid) || platform === "win32") return null;
+  const { ok, stdout } = await run("/bin/ps", ["-ww", "-p", String(pid), "-o", "lstart=,args="],
+    { timeout: timeoutMs });
+  if (!ok) return null;
+  const line = /^(.{24})\s+(.+)$/.exec(stdout.trim());
+  if (line === null || !STARTED.test(line[1])) return null;
+  const server = desktopServer(line[2]);
+  if (server === null) return null;
+  const token = flagValue(server.words, "--csrf_token");
+  if (typeof token !== "string" || token === "" || token.startsWith("-")) return null;
+  return { startedAt: line[1], executable: server.executable, version: server.version, token };
+}
+
+// Where lsof lives: /usr/sbin on macOS, /usr/bin on Linux. Never PATH: a
+// directory an operator can write to must not supply the tool that names the
+// port a token is sent to.
+const LSOF_CANDIDATES = Object.freeze(["/usr/sbin/lsof", "/usr/bin/lsof"]);
+const LOOPBACK = new Set(["127.0.0.1", "localhost", "[::1]"]);
+
+async function resolveLsof() {
+  for (const candidate of LSOF_CANDIDATES) {
+    try { await access(candidate, constants.X_OK); return candidate; } catch { /* next */ }
+  }
+  return null;
+}
+
+/** The loopback TCP ports `pid` listens on, in the order lsof lists them. */
+export async function listeningPorts(pid, { run = runFile, lsof = resolveLsof, timeoutMs = 1_000 } = {}) {
+  const file = await lsof();
+  if (file === null || !isPid(pid)) return [];
+  const { stdout } = await run(file, ["-nP", "-a", "-p", String(pid), "-iTCP", "-sTCP:LISTEN", "-Fn"],
+    { timeout: timeoutMs });
+  const ports = [];
+  for (const line of stdout.split("\n")) {
+    const match = /^n(.+):(\d+)$/.exec(line.trim());
+    if (match === null || !LOOPBACK.has(match[1])) continue;
+    const port = Number(match[2]);
+    if (port > 0 && port < 65_536 && !ports.includes(port)) ports.push(port);
+  }
+  return ports;
+}
+
+/**
+ * Whether a loopback port is the server's plain-HTTP endpoint, the one
+ * `agentapi` talks to. The server's other port speaks TLS and answers a plain
+ * request with 400; the HTTP one answers `/healthz` with 200 (2.19.1). No token
+ * is sent.
+ */
+export function answersHealth(port, { timeoutMs = 500 } = {}) {
+  return new Promise(resolve => {
+    const request = http.get({ host: "127.0.0.1", port, path: "/healthz", timeout: timeoutMs }, response => {
+      response.resume();
+      resolve(response.statusCode === 200);
+    });
+    request.on("timeout", () => { request.destroy(); resolve(false); });
+    request.on("error", () => resolve(false));
+  });
+}
+
+/** The first of the server's ports that answers as its HTTP endpoint, or null. */
+export async function httpPort(pid, { ports = listeningPorts, health = answersHealth } = {}) {
+  for (const port of await ports(pid)) {
+    if (await health(port)) return port;
+  }
+  return null;
+}

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

@@ -5,14 +5,16 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { promisify } from "node:util";
 
-import { bakeSkillCommand, blankJson, defaultAntigravityRelay, isShellWord, ownVersion,
-  removeIfEmpty, stampPluginVersion, writeCliShim, writeForeignJson, writeHookShim }
+import { bakeSkillCommand, blankJson, defaultAntigravityRelay, isShellWord, mergeEnv, ownVersion,
+  removeIfEmpty, shellQuote, shortPath, stampPluginVersion, windowsHookCommand, writeCliShim,
+  writeForeignJson, writeHookShim, writeNodeShim }
   from "@agents-can-communicate/adapter-sdk";
 import { AccError, EXIT } from "@agents-can-communicate/protocol";
 
-import { agySettingsPath, cliWrapperPath, ensureAllowRule, inspectAllowRule,
+import { agySettingsPath, cliWrapperPath, ensureAllowRule, inspectAllowRule, inspectRelayRule,
   withdrawAllowRule } from "./allow-rule.mjs";
-import { relayShimPath, runningRelays, stopRelays } from "./relays.mjs";
+import { ensureDesktopRule, inspectDesktopRule, withdrawDesktopRule } from "./desktop-allow-rule.mjs";
+import { relayShimName, relayStartCommand, runningRelays, stopRelays } from "./relays.mjs";
 
 const run = promisify(execFile);
 
@@ -181,9 +183,15 @@ const exists = async target => {
  * Each command carries its own event name, because the payload does not. The
  * same shim answers every event and is told which one it is running as.
  */
-export function accHookConfig(shim) {
+export function accHookConfig(shim, { platform = process.platform } = {}) {
+  // On Windows this client runs a hook through Go's `cmd /c`, which escapes an
+  // inner quote as `\"` - a form cmd does not read (google-antigravity/
+  // antigravity-cli#222). The command therefore carries no quotes at all.
+  const command = event => (platform === "win32"
+    ? windowsHookCommand("unquoted", { node: process.execPath, shim, args: [event] })
+    : `sh ${shellQuote(shim)} ${event}`);
   return { [ACC_NAMESPACE]: Object.fromEntries(ACC_REGISTERED_EVENTS.map(event =>
-    [event, [{ type: "command", command: `sh "${shim}" ${event}`, timeout: 10 }]])) };
+    [event, [{ type: "command", command: command(event), timeout: 10 }]])) };
 }
 
 /**
@@ -224,7 +232,7 @@ export function registeredSource(readback) {
  */
 async function runAgy(args, { home, env, timeoutMs = 60_000 } = {}) {
   return run("agy", args, { timeout: timeoutMs,
-    env: { ...process.env, ...env, ...(typeof home === "string" ? { HOME: home } : {}) } });
+    env: mergeEnv(process.env, { ...env, ...(typeof home === "string" ? { HOME: home } : {}) }) });
 }
 
 const agyFor = context => context.runAgy ?? runAgy;
@@ -308,8 +316,6 @@ const importedCopy = readback => (Array.isArray(readback?.skills) ? readback.ski
  * directory, so it outlives the Gemini CLI integration this client otherwise
  * borrows from.
  */
-const shellQuote = value => `"${String(value).replace(/(["\\$`])/g, "\\$1")}"`;
-
 /**
  * The command ACC's context line and skill tell the agent to run once per
  * conversation. It has to run in the agent's own shell - that is the only
@@ -317,8 +323,13 @@ const shellQuote = value => `"${String(value).replace(/(["\\$`])/g, "\\$1")}"`;
  * not something ACC could start on its behalf. It never falls back to `acc`
  * on the PATH the way the CLI shim does: `acc start` is not a command.
  */
-async function writeRelayShim({ home, relay = defaultAntigravityRelay(), node = process.execPath }) {
-  const target = relayShimPath(home);
+async function writeRelayShim({ home, relay = defaultAntigravityRelay(), node = process.execPath,
+  platform = process.platform }) {
+  const target = path.join(shimDir(home), relayShimName(platform));
+  if (platform === "win32") {
+    return writeNodeShim({ file: target, target: relay, node, goneExit: 0,
+      gone: "ACC: live delivery is not installed here; run acc install --adapter antigravity" });
+  }
   await mkdir(path.dirname(target), { recursive: true });
   await writeFile(target, [
     "#!/bin/sh",
@@ -341,10 +352,10 @@ async function writeRelayShim({ home, relay = defaultAntigravityRelay(), node =
 }
 
 async function installSkillPlugin(context) {
-  const { home, cli, node } = context;
+  const { home, cli, node, hostPlatform = process.platform } = context;
   const manifestExisted = await exists(vendorManifestPath(home));
-  const cliShim = await writeCliShim({ dir: shimDir(home), cli, node });
-  await writeRelayShim({ home, relay: context.antigravityRelay, node });
+  const cliShim = await writeCliShim({ dir: shimDir(home), cli, node, platform: hostPlatform });
+  await writeRelayShim({ home, relay: context.antigravityRelay, node, platform: hostPlatform });
   const stage = await mkdtemp(path.join(tmpdir(), "acc-antigravity-plugin-"));
   try {
     const plugin = path.join(stage, ACC_PLUGIN_NAME);
@@ -353,7 +364,7 @@ async function installSkillPlugin(context) {
       version: await ownVersion(import.meta.url), io: { readFile, writeFile } });
     // Bare when the path allows it: 1.2.12 matched no allow rule against a
     // command whose first word was quoted (issue #214).
-    await bakeSkillCommand({ root: plugin, cliShim, bareWhenSafe: true });
+    await bakeSkillCommand({ root: plugin, cliShim, bareWhenSafe: true, platform: hostPlatform });
     await agyFor(context)(["plugin", "install", plugin], { home, env: context.env });
   } finally {
     await rm(stage, { recursive: true, force: true });
@@ -382,14 +393,21 @@ async function installSkillPlugin(context) {
  * unverified - never as registered.
  */
 export async function installAntigravity(context) {
-  const { home, runner, node } = context;
+  const { home, runner, node, hostPlatform = process.platform } = context;
   const file = hooksPathFor(context);
   const found = await readJson(file, null);
   const existing = found ?? {};
 
-  const shim = await writeHookShim({ dir: shimDir(home), adapterId: "antigravity",
-    runner, node });
-  const merged = { ...existing, ...accHookConfig(shim) };
+  const written = await writeHookShim({ dir: shimDir(home), adapterId: "antigravity",
+    runner, node, platform: hostPlatform });
+  // A profile path with a space ("C:\Users\First Last") goes in by its 8.3 name.
+  const shim = hostPlatform === "win32" ? await shortPath(written) : written;
+  if (hostPlatform === "win32" && /\s/.test(shim)) {
+    throw new AccError(EXIT.DATA, "Antigravity CLI cannot run a hook whose path has a space, and "
+      + `this volume gives ${written} no 8.3 name; enable 8.3 names on it `
+      + "(fsutil 8dot3name set <drive>: 0) and run acc install again", { shim: written });
+  }
+  const merged = { ...existing, ...accHookConfig(shim, { platform: hostPlatform }) };
   await mkdir(path.dirname(file), { recursive: true });
   await writeForeignJson(file, merged, { readFile, writeFile, mkdir });
   // Recorded beside the shim, never inside the client's file. A file holding
@@ -405,11 +423,13 @@ export async function installAntigravity(context) {
   await installSkillPlugin(context);
   // After the skill, whose wrapper the rule names. Always on (#214, 2026-09-27).
   const allow = await ensureAllowRule(context);
+  // Antigravity 2.0 keeps grants of its own, read only where it has run.
+  const desktop = await ensureDesktopRule(context);
   const changes = [shimDir(home), file, pluginInstallPath(home), vendorManifestPath(home),
-    ...allow.changes];
+    ...allow.changes, ...desktop.changes];
 
-  const diagnostics = [...allow.diagnostics];
-  const needsAction = [...allow.needsAction];
+  const diagnostics = [...allow.diagnostics, ...desktop.diagnostics];
+  const needsAction = [...allow.needsAction, ...desktop.needsAction];
   if (locationOf(context) === "workspace") {
     diagnostics.push("a workspace registration loads only while this project is an open "
       + `Antigravity workspace; in print mode pass --add-dir ${context.antigravityWorkspace}`);
@@ -533,12 +553,14 @@ export async function uninstallAntigravity(context) {
 
   // The allow rule ACC recorded adding, and nothing else in the operator's file.
   const allow = await withdrawAllowRule(context);
-  changes.push(...allow.changes);
-  diagnostics.push(...allow.diagnostics);
+  const desktop = await withdrawDesktopRule(context);
+  changes.push(...allow.changes, ...desktop.changes);
+  diagnostics.push(...allow.diagnostics, ...desktop.diagnostics);
+  const needsAction = [...allow.needsAction, ...desktop.needsAction];
 
   if (!keep.includes(shimDir(home))) await rm(shimDir(home), { recursive: true, force: true });
   return { ok: true, changes, diagnostics,
-    ...(allow.needsAction.length > 0 ? { needsAction: allow.needsAction } : {}) };
+    ...(needsAction.length > 0 ? { needsAction } : {}) };
 }
 
 /**
@@ -576,9 +598,13 @@ export async function detectAntigravity(context) {
   // Read from files only, so it is known for a client ACC did not run. It is
   // the client's own approval control over what a woken session can answer.
   const commandApproval = await inspectAllowRule(context);
-  const approval = { commandApproval,
+  const relayApproval = await inspectRelayRule(context);
+  const desktopApproval = await inspectDesktopRule(context);
+  const approval = { commandApproval, relayApproval,
     inboundDelivery: { state: commandApproval.state, diagnostic: commandApproval.diagnostic } };
   diagnostics.push(commandApproval.diagnostic);
+  if (relayApproval.state !== "unreadable") diagnostics.push(relayApproval.diagnostic);
+  if (desktopApproval.diagnostic !== null) diagnostics.push(desktopApproval.diagnostic);
   // The installer runs every adapter's detect and passes a null version for a
   // client it did not find. Asking agy then would spawn a binary the installer
   // could not run a moment ago, or - where it does exist but did not answer -
@@ -644,7 +670,7 @@ export async function detectAntigravity(context) {
   }
   // Every install writes the rule, so where ACC's wrapper is on disk a missing
   // or unreadable rule is an install to finish, whatever the delivery policy.
-  if (await exists(cliWrapperPath(context.home))) {
+  if (await exists(cliWrapperPath(context.home, context.hostPlatform))) {
     if (commandApproval.state === "prompts") {
       needsAction.push(`acc install --adapter antigravity  # ${commandApproval.rule} is missing `
         + `from permissions.allow in ${commandApproval.file}, so each ACC command waits for `
@@ -652,6 +678,11 @@ export async function detectAntigravity(context) {
     } else if (commandApproval.state === "unreadable") {
       needsAction.push(commandApproval.diagnostic);
     }
+    if (relayApproval.state === "prompts") {
+      needsAction.push(`acc install --adapter antigravity  # ${relayApproval.rule} is missing `
+        + `from permissions.allow in ${relayApproval.file}, so the agent asks before it starts `
+        + "live delivery");
+    }
   }
   if (blocked !== null) {
     diagnostics.push(blocked.reason);
@@ -684,8 +715,8 @@ export async function doctorAntigravity(context) {
   if (locationOf(context) === "workspace") {
     diagnostics.push("registered per workspace; a session opened anywhere else loads nothing");
   }
-  diagnostics.push(`live delivery starts when the agent runs sh "${relayShimPath(context.home)}" `
-    + "start once in a conversation; while none is serving, ACC asks for that in its context "
+  diagnostics.push(`live delivery starts when the agent runs ${relayStartCommand(context.home,
+    context.hostPlatform)} once in a conversation; while none is serving, ACC asks for that in its context `
     + "line, up to three times, when the policy is on");
   diagnostics.push(`antigravity relays running on this machine: ${await runningRelays({
     dataHome: context.dataHome })}`);
@@ -713,7 +744,7 @@ export function planAntigravityInstall(context) {
   // match: a wrapper path that needs quotes gets none.
   const plugin = [{ path: pluginInstallPath(context.home), kind: "merge" },
     { path: vendorManifestPath(context.home), kind: "merge" },
-    ...(isShellWord(cliWrapperPath(context.home))
+    ...(isShellWord(cliWrapperPath(context.home, context.hostPlatform))
       ? [{ path: agySettingsPath(context.home), kind: "merge" }] : [])];
   if (locationChoice(context) !== null) {
     return [shim, ...plugin,