agents-can-communicate 0.8.4 → 0.9.0

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

@@ -2,7 +2,7 @@ import { createHash } from "node:crypto";
 import { mkdir, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
 
-import { decisionBody } from "@agents-can-communicate/adapter-sdk";
+import { decisionBody, isLaunchOption } from "@agents-can-communicate/adapter-sdk";
 
 import { CODEX_QUEUE_MINIMUM, MINIMUM_VERSION, PROTOCOL_CONTRACT, QUEUE_MODES,
   addCodexQueueMessage, canonicalCwd, compareVersions, controlSocketPath,
@@ -10,7 +10,7 @@ import { CODEX_QUEUE_MINIMUM, MINIMUM_VERSION, PROTOCOL_CONTRACT, QUEUE_MODES,
   versionOrder } from "./app-server-client.mjs";
 import { newEndpointId, readNativeEndpoint, readySocketPath, removeNativeEndpoint, socketIsReady,
   writeNativeEndpoint } from "./native-endpoint.mjs";
-import { hostArgv, runsEmbedded } from "./embedded-host.mjs";
+import { embeddedHost, hostArgv } from "./embedded-host.mjs";
 
 // The receiver's hook supplies thread and cwd. Core holds only a random endpoint
 // reference; sender environment never decides which daemon receives the message.
@@ -36,10 +36,12 @@ async function usingPeer(socketPath, timeoutMs, open, run) {
 }
 
 export async function probeNativeDelivery({ timeoutMs = 750, env = process.env,
-  open = openCodexAppServer } = {}) {
+  open = openCodexAppServer, platform = process.platform } = {}) {
   const unsupported = (reasonCode, clientVersion = null) => ({ supported: false, clientVersion,
     protocolContract: PROTOCOL_CONTRACT, executableFingerprint: null, modes: [], reasonCode });
-  const socketPath = await readySocketPath(controlSocketPath(env));
+  // Windows reaches the daemon's AF_UNIX socket through `codex app-server proxy`
+  // (openCodexAppServer); everything past the transport is the same.
+  const socketPath = await readySocketPath(controlSocketPath(env), { platform });
   if (socketPath === null) return unsupported("native_endpoint_unavailable");
   try {
     return await usingPeer(socketPath, timeoutMs, open, async peer => {
@@ -107,22 +109,26 @@ export async function verifyReceiver(peer, endpoint, { probe = probeCodexQueue,
 // A chat that runs embedded has no receiver for any check below to find. Its
 // host process is read only after a check failed, so a bound session never pays
 // for it, and the reason then names the cause instead of the symptom.
-export async function bindNativeSession({ argvOf = hostArgv, ...options } = {}) {
-  const result = await bindAttempt(options);
+export async function bindNativeSession({ argvOf = hostArgv, platform = process.platform,
+  ...options } = {}) {
+  const result = await bindAttempt({ ...options, platform });
   if (result.supported || !Number.isInteger(options.clientPid) || options.clientPid <= 0) return result;
-  return await runsEmbedded(options.clientPid, argvOf)
-    ? closed(options.clientVersion, "client_session_embedded") : result;
+  const host = await embeddedHost(options.clientPid, argvOf);
+  if (host === null) return result;
+  const refusal = closed(options.clientVersion, "client_session_embedded");
+  return host.launchOption === null ? refusal : { ...refusal, launchOption: host.launchOption };
 }
 
 async function bindAttempt({ event, clientPid, clientVersion, runtimeDir,
-  env = process.env, timeoutMs = 750, now = Date.now, open = openCodexAppServer } = {}) {
+  env = process.env, timeoutMs = 750, now = Date.now, open = openCodexAppServer,
+  platform = process.platform } = {}) {
   const rejected = reason => closed(clientVersion, reason);
   if (!Number.isInteger(clientPid) || clientPid <= 0) return rejected("client_process_unknown");
   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 readySocketPath(controlSocketPath(env));
+  const socketPath = await readySocketPath(controlSocketPath(env), { platform });
   if (socketPath === null) return rejected("handshake_failed");
   try {
     return await usingPeer(socketPath, timeoutMs, open, async peer => {
@@ -136,7 +142,7 @@ async function bindAttempt({ event, clientPid, clientVersion, runtimeDir,
       // 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 });
+      await writeNativeEndpoint({ runtimeDir, record: verified, platform });
       return handshake(verified, now);
     });
   } catch (error) {
@@ -161,15 +167,15 @@ async function bindAttempt({ event, clientPid, clientVersion, runtimeDir,
 // 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 !== null && await socketIsReady(endpoint.socketPath) ? endpoint : null;
+async function receiverFor(binding, runtimeDir, platform = process.platform) {
+  const endpoint = await readNativeEndpoint({ runtimeDir, endpointId: binding?.opaqueEndpointRef, platform });
+  return endpoint !== null && await socketIsReady(endpoint.socketPath, { platform }) ? endpoint : null;
 }
 
 export async function refreshNativeSession({ binding, runtimeDir, timeoutMs = 750,
-  now = Date.now, open = openCodexAppServer } = {}) {
+  now = Date.now, open = openCodexAppServer, platform = process.platform } = {}) {
   const rejected = reason => closed(binding?.clientVersion, reason);
-  const endpoint = await receiverFor(binding, runtimeDir);
+  const endpoint = await receiverFor(binding, runtimeDir, platform);
   if (endpoint === null) return rejected("handshake_failed");
   try {
     return await usingPeer(endpoint.socketPath, timeoutMs, open, async peer => {
@@ -183,10 +189,10 @@ export async function refreshNativeSession({ binding, runtimeDir, timeoutMs = 75
 }
 
 export async function offerMessage({ binding, message, runtimeDir, timeoutMs = 5_000,
-  open = openCodexAppServer } = {}) {
+  open = openCodexAppServer, platform = process.platform } = {}) {
   const rejected = safeErrorCode => ({ accepted: false, transport: "codex-app-server",
     clientVersion: binding?.clientVersion ?? null, safeErrorCode });
-  const endpoint = await receiverFor(binding, runtimeDir);
+  const endpoint = await receiverFor(binding, runtimeDir, platform);
   if (endpoint === null) return rejected("recipient_unavailable");
   try {
     return await usingPeer(endpoint.socketPath, timeoutMs, open, async peer => {
@@ -205,17 +211,48 @@ export async function offerMessage({ binding, message, runtimeDir, timeoutMs = 5
   }
 }
 
-export const retireNativeSession = ({ binding, runtimeDir }) =>
-  removeNativeEndpoint({ runtimeDir, endpointId: binding?.opaqueEndpointRef });
+export const retireNativeSession = ({ binding, runtimeDir, platform = process.platform }) =>
+  removeNativeEndpoint({ runtimeDir, endpointId: binding?.opaqueEndpointRef, platform });
 
-const EMBEDDED_NOTICE = "ACC: live peer delivery is off in this Codex chat. It runs on its own "
-  + "embedded app server, so peer messages reach it only with the user's next prompt. Tell the "
-  + "user once: for live delivery, open a new Codex chat; if Codex does not start its app-server "
-  + "daemon itself, run `codex app-server daemon start` first.";
+const OPEN_A_CHAT = "open a new Codex chat; if Codex does not start its app-server daemon itself, "
+  + "run `codex app-server daemon start` first";
+// Options a setting in config.toml can replace; the rest are simply left off.
+const SETTING_OPTIONS = new Set(["-c", "--config", "--enable", "--disable", "--search", "-p",
+  "--profile"]);
+
+// What the chat is told: one line for the model, one the client shows the user
+// (Codex prints a hook's systemMessage, which never reaches the model).
+function embeddedNotice(launchOption) {
+  if (!isLaunchOption(launchOption)) {
+    return { line: "ACC: live peer delivery is off in this Codex chat. It runs on its own embedded "
+      + "app server, so peer messages reach it only with the user's next prompt. ACC has shown the "
+      + `user how to get it: ${OPEN_A_CHAT}.`,
+    userMessage: "ACC: live peer delivery is off in this chat, which runs on its own app server. "
+      + `For live delivery, ${OPEN_A_CHAT}.` };
+  }
+  const advice = `start Codex without \`${launchOption}\``
+    + (SETTING_OPTIONS.has(launchOption) ? " and move what it sets into config.toml" : "");
+  return { line: `ACC: live peer delivery is off in this Codex chat. It was started with `
+    + `\`${launchOption}\`, so it runs on its own embedded app server and peer messages reach it `
+    + `only with the user's next prompt. ACC has shown the user how to get it: ${advice}.`,
+  userMessage: `ACC: live peer delivery is off in this chat: \`${launchOption}\` makes Codex run `
+    + `it on its own app server. For live delivery, ${advice}.` };
+}
+
+// A chat the Codex app serves itself: nothing the user starts differently
+// changes that, so the notice says what happens instead of what to do.
+const DESKTOP_NOTICE = Object.freeze({
+  line: "ACC: live peer delivery is off in this Codex chat. The Codex app runs it on its own app "
+    + "server, which no other process can reach, so peer messages arrive with the user's next "
+    + "prompt. ACC has shown the user this.",
+  userMessage: "ACC: live peer delivery is off in this chat: the Codex app runs it on its own app "
+    + "server. Peer messages arrive with your next prompt.",
+});
 
 // One delivered notice per chat. The marker is created exclusively, so a
 // second turn finds it; a notice the runner did not deliver gives it back.
-export async function nativeActivationHint({ event, nativeBinding, runtimeDir }) {
+export async function nativeActivationHint({ event, nativeBinding, runtimeDir, clientPid,
+  argvOf = hostArgv }) {
   if (nativeBinding?.state !== "degraded" || nativeBinding.reasonCode !== "client_session_embedded"
     || typeof event?.sessionId !== "string" || event.sessionId === ""
     || typeof runtimeDir !== "string") return null;
@@ -227,7 +264,10 @@ export async function nativeActivationHint({ event, nativeBinding, runtimeDir })
   } catch {
     return null;
   }
-  return { line: EMBEDDED_NOTICE, release: () => rm(marker, { force: true }) };
+  const host = Number.isInteger(clientPid) && clientPid > 0 && !isLaunchOption(nativeBinding.launchOption)
+    ? await embeddedHost(clientPid, argvOf) : null;
+  const notice = host?.desktop === true ? DESKTOP_NOTICE : embeddedNotice(nativeBinding.launchOption);
+  return { ...notice, release: () => rm(marker, { force: true }) };
 }
 
 function renderText(message) {

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

@@ -1,8 +1,9 @@
 import { randomBytes } from "node:crypto";
-import { constants } from "node:fs";
-import { lstat, mkdir, open, realpath, rename, rm } from "node:fs/promises";
+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";
+
 import { PROTOCOL_CONTRACT, versionOrder } from "./app-server-client.mjs";
 
 const KEYS = ["schemaVersion", "endpointId", "socketPath", "threadId", "cwd",
@@ -28,7 +29,7 @@ function valid(record) {
     && Number.isFinite(Date.parse(record.leaseUntil));
 }
 
-async function directory(runtimeDir, create = false) {
+async function directory(runtimeDir, create = false, platform = process.platform) {
   if (!absolute(runtimeDir)) throw invalid();
   if (create) await mkdir(runtimeDir, { recursive: true, mode: 0o700 });
   const root = await realpath(runtimeDir);
@@ -37,11 +38,25 @@ async function directory(runtimeDir, create = false) {
     if (error.code !== "EEXIST") throw error;
   });
   const info = await lstat(dir);
-  if (!info.isDirectory() || info.isSymbolicLink() || !own(info) || (info.mode & 0o022) !== 0) throw invalid();
+  if (!info.isDirectory() || info.isSymbolicLink() || !own(info) || !closedTo(info, 0o022, { platform })) {
+    throw invalid();
+  }
   return dir;
 }
 
-export async function socketIsReady(socketPath) {
+/**
+ * An owned socket, never itself a link. On Windows Node's lstat refuses the
+ * daemon's AF_UNIX socket file with EACCES (measured on windows-latest, Codex
+ * 0.159.3), so there the socket counts while its directory lists it; Codex keeps
+ * that directory to its user.
+ */
+export async function socketIsReady(socketPath, { platform = process.platform } = {}) {
+  if (isWindowsPlatform(platform)) {
+    if (!absolute(socketPath)) return false;
+    const name = path.basename(socketPath).toLowerCase();
+    const names = await readdir(path.dirname(socketPath)).catch(() => []);
+    return names.some(entry => entry.toLowerCase() === name);
+  }
   if (!absolute(socketPath)) return false;
   try {
     const info = await lstat(socketPath);
@@ -53,7 +68,14 @@ export async function socketIsReady(socketPath) {
  * 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) {
+export async function readySocketPath(socketPath, { platform = process.platform } = {}) {
+  if (isWindowsPlatform(platform)) {
+    // The socket file itself refuses to be opened; its directory resolves.
+    if (!absolute(socketPath)) return null;
+    const directory = await realpath(path.dirname(socketPath)).catch(() => null);
+    const resolved = directory === null ? null : path.join(directory, path.basename(socketPath));
+    return resolved !== null && await socketIsReady(resolved, { platform }) ? resolved : null;
+  }
   if (!absolute(socketPath)) return null;
   const resolved = await realpath(socketPath).catch(() => null);
   return resolved !== null && await socketIsReady(resolved) ? resolved : null;
@@ -61,11 +83,11 @@ export async function readySocketPath(socketPath) {
 
 // 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 }) {
-  if (!valid(record) || !await socketIsReady(record.socketPath)) throw invalid();
+export async function writeNativeEndpoint({ runtimeDir, record, platform = process.platform }) {
+  if (!valid(record) || !await socketIsReady(record.socketPath, { 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;
@@ -82,25 +104,26 @@ export async function writeNativeEndpoint({ runtimeDir, record }) {
 
 // Expired records are metadata for revalidation, never proof of reachability.
 // Refuse links and oversized files before reading; no foreign error text escapes.
-export async function readNativeEndpoint({ runtimeDir, endpointId }) {
+export async function readNativeEndpoint({ runtimeDir, endpointId, platform = process.platform }) {
   if (typeof endpointId !== "string" || !ENDPOINT.test(endpointId)) return null;
   let handle;
   try {
-    const dir = await directory(runtimeDir);
-    handle = await open(path.join(dir, `${endpointId}.json`),
-      constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    const 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 valid(record) && record.endpointId === endpointId ? record : null;
   } catch { return null; }
   finally { await handle?.close().catch(() => null); }
 }
 
-export async function removeNativeEndpoint({ runtimeDir, endpointId }) {
+export async function removeNativeEndpoint({ runtimeDir, endpointId, platform = process.platform }) {
   if (typeof endpointId !== "string" || !ENDPOINT.test(endpointId)) return;
   try {
-    const dir = await directory(runtimeDir);
+    const dir = await directory(runtimeDir, false, platform);
     await rm(path.join(dir, `${endpointId}.json`), { force: true });
   } catch { /* retirement is already recorded; cleanup is best effort */ }
 }

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

@@ -75,8 +75,10 @@ export function refusesConnections(socketPath, { timeoutMs = 1_000 } = {}) {
   });
 }
 
+// `connect` returns the byte stream to speak over: a socket by default, or on
+// Windows the stdio of `codex app-server proxy`, which relays to the same server.
 export function openWebSocketPeer({ socketPath, timeoutMs, path = "/", host = "localhost",
-  retainNotifications = true }) {
+  retainNotifications = true, connect = () => net.createConnection(socketPath) }) {
   const notifications = [];
   const pending = new Map();
   const key = randomBytes(16).toString("base64");
@@ -90,7 +92,7 @@ export function openWebSocketPeer({ socketPath, timeoutMs, path = "/", host = "l
   const ready = new Promise((resolve, reject) => { resolveReady = resolve; rejectReady = reject; });
   ready.catch(() => {});
 
-  const socket = net.createConnection(socketPath);
+  const socket = connect();
   socket.on("connect", () => socket.write(`GET ${path} HTTP/1.1\r\nHost: ${host}\r\n`
     + `Upgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Key: ${key}\r\n`
     + "Sec-WebSocket-Version: 13\r\n\r\n"));

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

@@ -1,6 +1,6 @@
 {
   "name": "agents-can-communicate",
-  "version": "0.8.4",
+  "version": "0.9.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.8.4",
+  "version": "0.9.0",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -43,7 +43,8 @@ export function createGeminiCliAdapter() {
     // The binary this client actually installs. Probed for a version to
     // decide whether the client is on this machine, so it has to be the
     // real command rather than the adapter id: `0.57.0`.
-    client: { command: "gemini", certificationName: "gemini-cli", versionArgs: ["--version"] },
+    client: { command: "gemini", package: "@google/gemini-cli", certificationName: "gemini-cli",
+      versionArgs: ["--version"] },
     certification,
     capabilities: {
       lifecycle: { sessionStart: true, sessionEnd: true },

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

@@ -6,7 +6,7 @@ import { fileURLToPath } from "node:url";
 
 import { acccreatedFile, bakeSkillCommand, blankJson, ownVersion, removeIfEmpty,
   removeInstalledTree,
-  stampPluginVersion, writeCliShim, writeForeignJson, writeHookShim }
+  shellQuote, stampPluginVersion, windowsHookCommand, writeCliShim, writeForeignJson, writeHookShim }
   from "@agents-can-communicate/adapter-sdk";
 
 const bundle = fileURLToPath(new URL("../extension", import.meta.url));
@@ -46,11 +46,16 @@ const writeJson = (file, value) => writeForeignJson(file, value,
 const isOurs = hook => typeof hook?.name === "string" && hook.name.startsWith(OWNER_PREFIX);
 
 // Replace the bundle's placeholder command with the shim that was just written.
-const withShim = (wiring, shim) => ({ hooks: Object.fromEntries(
+// On Windows this client runs hooks through PowerShell, which has no `sh`: the
+// pinned node runs the Node shim there.
+const withShim = (wiring, shim, windowsNode = null) => ({ hooks: Object.fromEntries(
   Object.entries(wiring.hooks).map(([event, entries]) => [event, entries.map(entry => ({
     ...entry,
-    hooks: entry.hooks.map(hook => ({ ...hook,
-      command: `sh "${shim}" ${hook.command.split(" ").pop()}` })),
+    hooks: entry.hooks.map(hook => {
+      const kind = hook.command.split(" ").pop();
+      return { ...hook, command: windowsNode === null ? `sh ${shellQuote(shim)} ${kind}`
+        : windowsHookCommand("powershell", { node: windowsNode, shim, args: [kind] }) };
+    }),
   }))])) });
 
 /**
@@ -62,7 +67,8 @@ const withShim = (wiring, shim) => ({ hooks: Object.fromEntries(
  * No environment variable is copied or persisted. The extension declares what
  * it needs; secrets stay where the user put them.
  */
-export async function installGeminiExtension({ home, runner, cli, node }) {
+export async function installGeminiExtension({ home, runner, cli, node,
+  hostPlatform = process.platform }) {
   // Read before writing: a settings file that will not parse must not be found
   // out after the extension tree is already on disk.
   const found = await readJson(settingsPath(home), null);
@@ -82,15 +88,15 @@ export async function installGeminiExtension({ home, runner, cli, node }) {
   await rm(path.join(target, "hooks", "hooks.json"), { force: true });
   // The skill ships with a placeholder where the command belongs: `acc` is
   // not on PATH everywhere, and an agent that cannot run it improvises.
-  const cliShim = await writeCliShim({ dir: target, cli, node });
-  await bakeSkillCommand({ root: target, cliShim });
+  const cliShim = await writeCliShim({ dir: target, cli, node, platform: hostPlatform });
+  await bakeSkillCommand({ root: target, cliShim, platform: hostPlatform });
   // This client offers no plugin-root variable in a hook command, so the shim's
   // absolute path is written in at install time.
   const shim = await writeHookShim({ dir: path.join(target, "hooks"),
-    adapterId: "gemini_cli", runner, node });
+    adapterId: "gemini_cli", runner, node, platform: hostPlatform });
 
   const ours = withShim(await readJson(path.join(bundle, "hooks", "hooks.json"),
-    { hooks: {} }), shim);
+    { hooks: {} }), shim, hostPlatform === "win32" ? node ?? process.execPath : null);
   const file = settingsPath(home);
   const merged = { ...existing, hooks: { ...(existing.hooks ?? {}) } };
   // Recorded now: afterwards a settings file holding `{}` looks the same

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

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

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

@@ -3,7 +3,8 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 
 import { AccError, EXIT } from "@agents-can-communicate/protocol";
-import { bakeSkillCommand, removeInstalledTree, writeCliShim, writeHookShim }
+import { bakeSkillCommand, removeInstalledTree, shellQuote, windowsHookCommand, writeCliShim,
+  writeHookShim }
   from "@agents-can-communicate/adapter-sdk";
 
 const bundle = fileURLToPath(new URL("../plugin", import.meta.url));
@@ -15,7 +16,9 @@ export const grokHomeOf = context =>
   context.grokHome ?? path.join(context.home, ".grok");
 
 export const hooksFile = home => path.join(home, "hooks", HOOKS_NAME);
-export const shimPath = home => path.join(home, "hooks", SHIM_NAME);
+// Windows gets the Node shim: no Windows client can be relied on to have `sh`.
+export const shimPath = (home, platform = process.platform) => path.join(home, "hooks",
+  platform === "win32" ? SHIM_NAME.replace(/\.sh$/, ".mjs") : SHIM_NAME);
 export const skillPath = home => path.join(home, "skills", "acc");
 
 async function readJson(file, fallback) {
@@ -46,37 +49,44 @@ const writeJson = async (file, value) => {
 // for plugins; we install into ~/.grok/hooks, which is always trusted and does
 // not need [plugins].enabled. The shim's absolute path is written in at install
 // time, the same lesson Codex taught: a relative hook command fails silently.
-const withShim = (wiring, shim) => ({
+// On Windows this client runs hooks through the shell it detects - pwsh, Git
+// Bash or cmd - so the command is written in the one form all three read.
+const withShim = (wiring, shim, windowsNode = null) => ({
   description: wiring.description,
   hooks: Object.fromEntries(Object.entries(wiring.hooks).map(([event, entries]) =>
     [event, entries.map(entry => ({
       ...entry,
-      hooks: entry.hooks.map(hook => ({ ...hook,
-        command: `sh "${shim}" ${hook.command.split(" ").pop()}` })),
+      hooks: entry.hooks.map(hook => {
+        const kind = hook.command.split(" ").pop();
+        return { ...hook, command: windowsNode === null ? `sh ${shellQuote(shim)} ${kind}`
+          : windowsHookCommand("portable", { node: windowsNode, shim, args: [kind] }) };
+      }),
     }))])),
 });
 
-export async function installGrokHooks({ grokHome, home, runner, cli, node }) {
+export async function installGrokHooks({ grokHome, home, runner, cli, node,
+  hostPlatform = process.platform }) {
   const root = grokHome ?? grokHomeOf({ home, grokHome });
   const template = await readJson(path.join(bundle, "hooks", "hooks.json"), { hooks: {} });
   const shim = await writeHookShim({ dir: path.join(root, "hooks"), adapterId: "grok",
-    runner, node, name: SHIM_NAME });
+    runner, node, name: SHIM_NAME, platform: hostPlatform });
 
   const skills = skillPath(root);
   await rm(skills, { recursive: true, force: true });
   await mkdir(path.dirname(skills), { recursive: true });
   await cp(path.join(bundle, "skills", "acc"), skills, { recursive: true });
-  const cliShim = await writeCliShim({ dir: skills, cli, node });
-  await bakeSkillCommand({ root: skills, cliShim });
+  const cliShim = await writeCliShim({ dir: skills, cli, node, platform: hostPlatform });
+  await bakeSkillCommand({ root: skills, cliShim, platform: hostPlatform });
 
-  await writeJson(hooksFile(root), withShim(template, shim));
+  await writeJson(hooksFile(root), withShim(template, shim,
+    hostPlatform === "win32" ? node ?? process.execPath : null));
   return { ok: true, changes: [hooksFile(root), shim, skills], diagnostics: [] };
 }
 
-export async function uninstallGrokHooks({ grokHome, home, keep = [] }) {
+export async function uninstallGrokHooks({ grokHome, home, keep = [], hostPlatform }) {
   const root = grokHome ?? grokHomeOf({ home, grokHome });
   const changes = [];
-  for (const target of [hooksFile(root), shimPath(root), skillPath(root)]) {
+  for (const target of [hooksFile(root), shimPath(root, hostPlatform), skillPath(root)]) {
     if (await removeInstalledTree(target, keep)) changes.push(target);
   }
   return { ok: true, changes, diagnostics: [] };
@@ -87,7 +97,8 @@ export async function detectGrok({ grokHome, home }) {
   const wired = await readJson(hooksFile(root), null);
   const installed = typeof wired?.hooks?.SessionStart?.[0]?.hooks?.[0]?.command
     === "string"
-    && wired.hooks.SessionStart[0].hooks[0].command.includes(SHIM_NAME);
+    // The shell shim on POSIX, the Node shim on Windows.
+    && /acc-hook\.(?:sh|mjs)\b/.test(wired.hooks.SessionStart[0].hooks[0].command);
   return { ok: true, changes: [],
     diagnostics: [installed ? "acc hooks registered" : "acc hooks not registered"] };
 }
@@ -96,7 +107,7 @@ export function planGrokInstall(context) {
   const root = grokHomeOf(context);
   return [
     { path: hooksFile(root), kind: "tree" },
-    { path: shimPath(root), kind: "tree" },
+    { path: shimPath(root, context.hostPlatform), kind: "tree" },
     { path: skillPath(root), kind: "tree" },
   ];
 }

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

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

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

@@ -32,7 +32,8 @@ export function createKimiAdapter() {
     // The binary this client actually installs. Probed for a version to
     // decide whether the client is on this machine, so it has to be the
     // real command rather than the adapter id: `0.36.1`.
-    client: { command: "kimi", certificationName: "kimi", versionArgs: ["--version"] },
+    client: { command: "kimi", package: "@moonshot-ai/kimi-code", certificationName: "kimi",
+      versionArgs: ["--version"] },
     certification,
     capabilities: {
       lifecycle: { sessionStart: true, heartbeat: true },

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

@@ -4,9 +4,9 @@ import path from "node:path";
 import { AccError, EXIT } from "@agents-can-communicate/protocol";
 import { fileURLToPath } from "node:url";
 
-import { assertRunner, bakeSkillCommand, blankText, defaultRunner, removeIfEmpty,
-  ownVersion, stampPluginVersion,
-  removeInstalledTree, runnerExists, writeCliShim, writeForeignJson }
+import { assertRunner, bakeSkillCommand, blankText, defaultRunner, ownVersion, removeIfEmpty,
+  removeInstalledTree, runnerExists, shellQuote, stampPluginVersion, windowsHookCommand,
+  writeCliShim, writeForeignJson }
   from "@agents-can-communicate/adapter-sdk";
 
 const bundle = fileURLToPath(new URL("../plugin", import.meta.url));
@@ -99,13 +99,17 @@ export function stripBlock(source) {
   return kept.join("\n");
 }
 
-export function renderBlock(runner, node = process.execPath) {
+export function renderBlock(runner, node = process.execPath, platform = process.platform) {
   const entries = WIRING.map(({ event, kind, matcher }) => {
     // Both paths are shell-quoted inside the TOML string: a hook runs through a
     // shell, and a space in either path would otherwise split the command.
     // The interpreter is named outright rather than left to PATH, which a hook's
-    // environment does not reliably carry.
-    const command = `${tomlString(node)} ${tomlString(runner)} kimi ${kind}`;
+    // environment does not reliably carry. On Windows that shell is cmd.exe, and
+    // a TOML-escaped path inside the command would reach it with every
+    // backslash doubled.
+    const command = platform === "win32"
+      ? windowsHookCommand("cmd", { node, shim: runner, args: ["kimi", kind] })
+      : `${shellQuote(node)} ${shellQuote(runner)} kimi ${kind}`;
     const lines = ["[[hooks]]", `event = ${tomlString(event)}`,
       `command = ${tomlString(command)}`];
     if (matcher !== undefined) lines.push(`matcher = ${tomlString(matcher)}`);
@@ -121,7 +125,8 @@ const registerPlugin = (registry, root) => {
     plugins: [...plugins, { id: PLUGIN_NAME, root, source: "local", enabled: true }] };
 };
 
-export async function installKimiPlugin({ home, runner = defaultRunner(), node, cli }) {
+export async function installKimiPlugin({ home, runner = defaultRunner(), node, cli,
+  hostPlatform = process.platform }) {
   // A hook whose command does not exist fails silently, on every event, for as
   // long as it stays installed: the client reports nothing and ACC simply never
   // sees a session. Writing that entry and hoping is worse than refusing.
@@ -139,8 +144,8 @@ export async function installKimiPlugin({ home, runner = defaultRunner(), node,
     version: await ownVersion(import.meta.url), io: { readFile, writeFile } });
   // The skill ships with a placeholder where the command belongs: `acc` is
   // not on PATH everywhere, and an agent that cannot run it improvises.
-  const cliShim = await writeCliShim({ dir: target, cli, node });
-  await bakeSkillCommand({ root: target, cliShim });
+  const cliShim = await writeCliShim({ dir: target, cli, node, platform: hostPlatform });
+  await bakeSkillCommand({ root: target, cliShim, platform: hostPlatform });
 
   const file = configPath(home);
   const existing = await readText(file, "");
@@ -149,7 +154,7 @@ export async function installKimiPlugin({ home, runner = defaultRunner(), node,
   // user's last section cannot swallow our entries.
   const separator = withoutOurs === "" || withoutOurs.endsWith("\n") ? "" : "\n";
   await mkdir(path.dirname(file), { recursive: true });
-  await writeFile(file, `${withoutOurs}${separator}${renderBlock(runner, node)}\n`);
+  await writeFile(file, `${withoutOurs}${separator}${renderBlock(runner, node, hostPlatform)}\n`);
 
   const registry = registryPath(home);
   await mkdir(path.dirname(registry), { recursive: true });

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

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