agents-can-communicate 0.8.4 → 0.9.0

package/node_modules/@agents-can-communicate/cli/src/managed-runtime/download.mjs

@@ -38,10 +38,19 @@ export async function fetchRelease({ pin = null, env = process.env, get = fetch
   return { version: body.version, integrity, registry: registry.href };
 }
 
-async function npmCli(env) {
-  const directories = [path.dirname(process.execPath), ...(env.PATH ?? "").split(path.delimiter)];
+/** npm's own script, beside this node first. POSIX's `npm` links to it; on
+ * Windows that name is a shell script, and node would run it as JavaScript. */
+export async function npmCli(env, { platform = process.platform, execPath = process.execPath,
+  realpath: resolve = realpath } = {}) {
+  const flavour = platform === "win32" ? path.win32 : path.posix;
+  // A copy of Windows' environment keeps the variable's own spelling, `Path`.
+  const search = Object.entries(env).find(([name]) => name.toUpperCase() === "PATH")?.[1] ?? "";
+  const directories = [flavour.dirname(execPath), ...search.split(flavour.delimiter)];
   for (const directory of directories.filter(Boolean)) {
-    try { return await realpath(path.join(directory, "npm")); } catch { /* Try the next installed npm. */ }
+    const candidate = platform === "win32"
+      ? flavour.join(directory, "node_modules", "npm", "bin", "npm-cli.js")
+      : flavour.join(directory, "npm");
+    try { return await resolve(candidate); } catch { /* Try the next installed npm. */ }
   }
   throw new Error("npm is unavailable; the working ACC runtime was kept");
 }

package/node_modules/@agents-can-communicate/cli/src/managed-runtime/entry.mjs

@@ -17,12 +17,14 @@ export const RETIRED_ENTRY_KINDS = Object.freeze(["acc-bootstrap", "acc-claude-c
 
 // Bootstrap resolution deliberately needs only Node built-ins: no selected
 // generation is imported until admission and its actual PID lease are durable.
+// The same rule as platformDataHome, which this module may not import.
 export function managerLocation({ env = process.env, platform = process.platform } = {}) {
-  const data = env.ACC_DATA_HOME || (platform === "win32" ? env.APPDATA
-    : platform === "darwin" ? env.HOME && path.join(env.HOME, "Library", "Application Support")
-      : env.XDG_DATA_HOME || env.HOME && path.join(env.HOME, ".local", "share"));
-  if (typeof data !== "string" || !path.isAbsolute(data)) throw new Error("cannot resolve ACC data home");
-  return path.join(data, "acc", "runtime");
+  const flavour = platform === "win32" ? path.win32 : path.posix;
+  const data = env.ACC_DATA_HOME || (platform === "win32" ? env.LOCALAPPDATA
+    : platform === "darwin" ? env.HOME && flavour.join(env.HOME, "Library", "Application Support")
+      : env.XDG_DATA_HOME || env.HOME && flavour.join(env.HOME, ".local", "share"));
+  if (typeof data !== "string" || !flavour.isAbsolute(data)) throw new Error("cannot resolve ACC data home");
+  return flavour.join(data, "acc", "runtime");
 }
 
 export function invokedDirectly(url) {

package/node_modules/@agents-can-communicate/cli/src/managed-runtime/generation.mjs

@@ -1,9 +1,11 @@
-import { lstat, mkdir, mkdtemp, open, readFile, readdir, realpath, rename, rm }
+import { lstat, mkdir, mkdtemp, open, readFile, readdir, realpath }
   from "node:fs/promises";
 import path from "node:path";
 
 import { collectFile, fingerprint } from "./generation-files.mjs";
+import { removeTree, renameEntry } from "./portable-fs.mjs";
 import { attachStagingTemp, holdStagedGeneration, releaseStagingHold } from "./staging.mjs";
+import { syncDirectory } from "./state.mjs";
 
 const NAME = "agents-can-communicate";
 const STABLE = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)$/;
@@ -144,19 +146,17 @@ export async function stageOwnGeneration({ packageRoot, managerRoot }) {
         } finally { await handle.close(); }
       }
       for (const directory of [...directories].sort((a, b) => b.length - a.length)) {
-        const handle = await open(directory, "r");
-        try { await handle.sync(); } finally { await handle.close(); }
+        await syncDirectory(directory);
       }
       try {
-        await rename(staging, target);
+        await renameEntry(staging, target);
       } catch (error) {
         if (!["EEXIST", "ENOTEMPTY"].includes(error.code) || !await existingMatches(target, files)) throw error;
       }
-      const handle = await open(generations, "r");
-      try { await handle.sync(); } finally { await handle.close(); }
+      await syncDirectory(generations);
       return { ...result, hold };
     } finally {
-      await rm(staging, { recursive: true, force: true });
+      await removeTree(staging);
     }
   } catch (error) {
     await releaseStagingHold(hold);

package/node_modules/@agents-can-communicate/cli/src/managed-runtime/launchers.mjs

@@ -1,11 +1,12 @@
 import { createHash, randomUUID } from "node:crypto";
-import { lstat, mkdtemp, open, readFile, rename, rm } from "node:fs/promises";
+import { lstat, mkdtemp, open, readFile, rm } from "node:fs/promises";
 import path from "node:path";
 import { ENTRY_KINDS, RETIRED_ENTRY_KINDS } from "./entry.mjs";
+import { removeTree, renameEntry, renameReplacing } from "./portable-fs.mjs";
 import { managedDirectory, syncDirectory } from "./state.mjs";
 
 const MODULES = ["entry.mjs", "command-prefix.mjs", "state.mjs", "generation-files.mjs",
-  "mutex.mjs", "leases.mjs", "schedule.mjs", "policy.mjs"];
+  "mutex.mjs", "leases.mjs", "schedule.mjs", "policy.mjs", "portable-fs.mjs"];
 async function durableFile(file, bytes, mode = 0o600) {
   const handle = await open(file, "wx", mode);
   try { await handle.writeFile(bytes); await handle.sync(); }
@@ -34,7 +35,7 @@ export async function writeLaunchers(root, packageRoot) {
   try {
     for (const [name, bytes] of modules) await durableFile(path.join(staging, name), bytes);
     await syncDirectory(staging);
-    try { await rename(staging, directory); }
+    try { await renameEntry(staging, directory); }
     catch (error) { if (!["EEXIST", "ENOTEMPTY"].includes(error.code)) throw error; }
     await managedDirectory(directory);
     for (const [name, bytes] of modules) {
@@ -43,7 +44,7 @@ export async function writeLaunchers(root, packageRoot) {
         || !(await readFile(file)).equals(bytes)) throw new Error("managed launcher integrity changed");
     }
     await syncDirectory(parent);
-  } finally { await rm(staging, { recursive: true, force: true }); }
+  } finally { await removeTree(staging); }
   const bin = path.join(root, "bin");
   await managedDirectory(bin, { create: true });
   for (const kind of ENTRY_KINDS) {
@@ -52,7 +53,9 @@ export async function writeLaunchers(root, packageRoot) {
     const temporary = path.join(bin, `.${randomUUID()}.tmp`);
     try {
       await durableFile(temporary, bytes, 0o700);
-      await rename(temporary, path.join(bin, `${kind}.mjs`));
+      // A launcher starting right now may still hold this file open; Windows
+      // refuses the replacement until it lets go.
+      await renameReplacing(temporary, path.join(bin, `${kind}.mjs`));
     } finally { await rm(temporary, { force: true }); }
   }
   // A 0.7.x `claude` shim or plugin copy that still reaches for one of these

package/node_modules/@agents-can-communicate/cli/src/managed-runtime/maintenance.mjs

@@ -75,7 +75,7 @@ export async function spawnMaintenance({ root, job, packageRoot, env }) {
     throw new Error("maintenance worker implementation is unavailable");
   }
   const child = spawn(process.execPath, [path.join(packageRoot, "bin", "acc-maintenance-worker.mjs"), root, job.id],
-    { env, cwd: root, detached: true, stdio: "ignore" });
+    { env, cwd: root, detached: true, windowsHide: true, stdio: "ignore" });
   await new Promise((resolve, reject) => { child.once("spawn", resolve); child.once("error", reject); });
   child.unref();
   return child.pid;

package/node_modules/@agents-can-communicate/cli/src/managed-runtime/mutex.mjs

@@ -1,7 +1,8 @@
 import { createHash, randomUUID } from "node:crypto";
-import { lstat, mkdir, readdir, rename, rm } from "node:fs/promises";
+import { lstat, mkdir, readdir } from "node:fs/promises";
 import path from "node:path";
 import { performance } from "node:perf_hooks";
+import { removeTree, renameEntry } from "./portable-fs.mjs";
 import { canonicalManagerRoot, managedDirectory, readManagedJson, syncDirectory, writeManagedJson } from "./state.mjs";
 
 export function defaultPidIsAlive(pid) {
@@ -49,7 +50,7 @@ async function readOwner(directory) {
 }
 
 async function retire(directory, target) {
-  try { await rename(directory, target); return true; }
+  try { await renameEntry(directory, target); return true; }
   catch (error) {
     if (["ENOENT", "EEXIST", "ENOTEMPTY"].includes(error.code)) return false;
     throw error;
@@ -81,10 +82,10 @@ async function compactQuiescentLocks(root, pidIsAlive) {
       const tombstone = path.join(root, name);
       const owner = await readOwner(tombstone);
       if (owner && name === `manager.reclaimed-${identity(owner)}.lock`) {
-        await rm(tombstone, { recursive: true, force: true });
+        await removeTree(tombstone);
       }
     }
-    for (const candidate of dead) await rm(candidate, { recursive: true, force: true });
+    for (const candidate of dead) await removeTree(candidate);
     await syncDirectory(root);
   } catch {
     // Maintenance is best effort. Unreadable/malformed preparation keeps the
@@ -118,7 +119,7 @@ export async function withManagerLock(root, operation, { timeoutMs = 1000, pidIs
         }
       } else {
         try {
-          await rename(candidate, directory);
+          await renameEntry(candidate, directory);
           owned = true;
           await syncDirectory(root);
           await compactQuiescentLocks(root, pidIsAlive);
@@ -140,6 +141,6 @@ export async function withManagerLock(root, operation, { timeoutMs = 1000, pidIs
         const released = path.join(root, `manager.reclaimed-${identity(owner)}.lock`);
         if (await retire(directory, released)) await syncDirectory(root);
       }
-    } else await rm(candidate, { recursive: true, force: true });
+    } else await removeTree(candidate);
   }
 }

package/node_modules/@agents-can-communicate/cli/src/managed-runtime/portable-fs.mjs

@@ -0,0 +1,165 @@
+// Filesystem calls whose meaning differs on Windows, each measured on a
+// windows-latest runner (docs/design/2026-09-30-native-windows-support.md).
+// POSIX keeps the single call it always made; the Windows branch keeps the rule
+// the caller relies on. Node built-ins only: the managed runtime's launchers
+// carry a byte-identical copy of this file, and they may import nothing else.
+import { constants } from "node:fs";
+import * as fs from "node:fs/promises";
+
+const BUSY = new Set(["EPERM", "EACCES", "EBUSY"]);
+// Long enough for a reader, an antivirus scan or an indexer to let go; short
+// enough that a hook's budget is spent on the write, not on waiting.
+const DEFAULT_WAIT_MS = 2_000;
+const BACKOFF_MS = [5, 10, 20, 40, 80];
+const STEADY_MS = 100;
+
+const sleepFor = duration => new Promise(resolve => { setTimeout(resolve, duration); });
+
+export const isWindows = (platform = process.platform) => platform === "win32";
+
+async function retrying(operation, retry, { deadlineAt, sleep = sleepFor }) {
+  const deadline = deadlineAt ?? Date.now() + DEFAULT_WAIT_MS;
+  for (let attempt = 0; ; attempt += 1) {
+    try {
+      return await operation();
+    } catch (error) {
+      const remaining = deadline - Date.now();
+      if (remaining <= 0 || !await retry(error)) throw error;
+      await sleep(Math.min(BACKOFF_MS[attempt] ?? STEADY_MS, remaining));
+    }
+  }
+}
+
+/**
+ * Rename a file over an existing one.
+ *
+ * Windows refuses the rename while any handle is open on the target - an ACC
+ * reader, an antivirus scan, an indexer - whatever sharing that handle allows.
+ * The handle is always short-lived, so the rename is retried until the caller's
+ * deadline rather than failing a write whose bytes are ready.
+ */
+export async function renameReplacing(from, to, { platform = process.platform,
+  rename = fs.rename, deadlineAt, sleep } = {}) {
+  if (!isWindows(platform)) return rename(from, to);
+  return retrying(() => rename(from, to), error => BUSY.has(error.code), { deadlineAt, sleep });
+}
+
+/**
+ * Rename a directory, or move any entry to a name nobody else uses.
+ *
+ * POSIX reports an occupied name as EEXIST or ENOTEMPTY, and callers treat that
+ * as "somebody else got there first". Windows reports it as EPERM, the same code
+ * it uses when a file inside the source is open. The target tells them apart:
+ * if it exists the answer is EEXIST, as on POSIX; if not, the source was busy
+ * and the rename is retried.
+ */
+export async function renameEntry(from, to, { platform = process.platform,
+  rename = fs.rename, lstat = fs.lstat, deadlineAt, sleep } = {}) {
+  if (!isWindows(platform)) return rename(from, to);
+  return retrying(async () => {
+    try {
+      return await rename(from, to);
+    } catch (error) {
+      if (!BUSY.has(error.code)) throw error;
+      const occupied = await lstat(to).then(() => true, missing => {
+        if (missing.code === "ENOENT") return false;
+        throw missing;
+      });
+      if (occupied) {
+        throw Object.assign(new Error(`EEXIST: file already exists, rename '${from}' -> '${to}'`),
+          { code: "EEXIST", syscall: "rename", path: from, dest: to });
+      }
+      throw error;
+    }
+  }, error => BUSY.has(error.code), { deadlineAt, sleep });
+}
+
+const gone = (file, lstat) => lstat(file).then(() => false,
+  error => error.code === "ENOENT");
+
+const refusedLink = file => Object.assign(
+  new Error(`ELOOP: too many symbolic links encountered, open '${file}'`),
+  { code: "ELOOP", syscall: "open", path: file });
+
+// How many times a name that keeps changing hands is opened afresh.
+const SWAPS = 3;
+
+/**
+ * Open a file without following a symlink at its final component.
+ *
+ * Windows has no O_NOFOLLOW: the flag is undefined there and an open through a
+ * file symlink succeeds. The rule is kept by checking the name first, refusing a
+ * symlink or junction (Node reports both as symbolic links), and after the open
+ * checking the name again: it must be no link, and name the very file the handle
+ * holds. A name another process replaced in between - a lock changing hands, a
+ * record renamed over - then names what was opened, as POSIX's O_NOFOLLOW open
+ * would have taken it; a name that moved on again is opened afresh, a few times.
+ */
+export async function openNoFollow(file, flags, { mode, platform = process.platform,
+  open = fs.open, lstat = fs.lstat, deadlineAt, sleep } = {}) {
+  if (!isWindows(platform)) return open(file, flags | constants.O_NOFOLLOW, mode);
+  for (let attempt = 1; ; attempt += 1) {
+    const before = await lstat(file, { bigint: true }).catch(error => {
+      if (error.code === "ENOENT") return null;
+      throw error;
+    });
+    if (before?.isSymbolicLink()) throw refusedLink(file);
+    // A scanner that opened the file without read sharing refuses every reader
+    // with EBUSY until it lets go.
+    const handle = await retrying(() => open(file, flags, mode), error => error.code === "EBUSY",
+      { deadlineAt, sleep }).catch(async error => {
+      // A name another process is deleting, or a lock changing hands around
+      // it, refuses the open with EPERM, and the name is gone right after
+      // (measured on windows-latest, for a name present before the open and
+      // for one absent before it): that is ENOENT, as Linux says it. A name
+      // that is still there keeps its EPERM, and so does a create on a name
+      // that was free, which is a refused create.
+      const refusedCreate = before === null && (flags & constants.O_CREAT) !== 0;
+      if (error.code !== "EPERM" || refusedCreate || !await gone(file, lstat)) throw error;
+      throw Object.assign(new Error(`ENOENT: no such file or directory, open '${file}'`,
+        { cause: error }), { code: "ENOENT", syscall: "open", path: file });
+    });
+    try {
+      const opened = await handle.stat({ bigint: true });
+      const named = await lstat(file, { bigint: true }).catch(error => {
+        if (error.code === "ENOENT") return null;
+        throw error;
+      });
+      if (named?.isSymbolicLink()) throw refusedLink(file);
+      if (named !== null && named.dev === opened.dev && named.ino === opened.ino) return handle;
+      if (attempt >= SWAPS) throw refusedLink(file);
+    } catch (error) {
+      await handle.close();
+      throw error;
+    }
+    await handle.close();
+  }
+}
+
+/**
+ * Make a rename or link that produced `entry` inside `directory` durable.
+ *
+ * POSIX syncs the directory. Windows refuses a flush on a directory handle, and
+ * NTFS journals the rename as metadata: flushing the renamed file commits that
+ * journal up to the file's last change, which includes the rename. A directory
+ * entry (a lock taken by renaming a directory) guards live processes only and is
+ * not flushed.
+ */
+export async function syncEntry(directory, entry, { platform = process.platform,
+  open = fs.open, lstat = fs.lstat, deadlineAt, sleep } = {}) {
+  if (!isWindows(platform)) {
+    const handle = await open(directory, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+    try { await handle.sync(); } finally { await handle.close(); }
+    return;
+  }
+  if ((await lstat(entry)).isDirectory()) return;
+  const handle = await retrying(() => open(entry, "r+"), error => error.code === "EBUSY",
+    { deadlineAt, sleep });
+  try { await handle.sync(); } finally { await handle.close(); }
+}
+
+/** Remove a tree; Windows retries a file another process still holds. */
+export async function removeTree(target, { platform = process.platform, rm = fs.rm } = {}) {
+  await rm(target, { recursive: true, force: true,
+    maxRetries: isWindows(platform) ? 10 : 0, retryDelay: 50 });
+}

package/node_modules/@agents-can-communicate/cli/src/managed-runtime/schedule.mjs

@@ -32,7 +32,7 @@ export async function scheduleWorker(root, control, { env = process.env } = {})
     }
     const child = spawn(process.execPath,
       [path.join(control.active.root, "bin", "acc-update-worker.mjs"), root], {
-        env, detached: true, stdio: "ignore", cwd: root,
+        env, detached: true, windowsHide: true, stdio: "ignore", cwd: root,
       });
     child.on("error", () => {});
     child.unref();

package/node_modules/@agents-can-communicate/cli/src/managed-runtime/state.mjs

@@ -1,8 +1,9 @@
 import { randomUUID } from "node:crypto";
 import { constants } from "node:fs";
-import { lstat, mkdir, open, realpath, rename, rm } from "node:fs/promises";
+import { lstat, mkdir, open, realpath, rm } from "node:fs/promises";
 import path from "node:path";
 import { collectFile, fingerprint } from "./generation-files.mjs";
+import { isWindows, openNoFollow, renameReplacing, syncEntry } from "./portable-fs.mjs";
 
 /** Resolve existing ancestors without creating an uninitialized manager. */
 export async function canonicalManagerRoot(root) {
@@ -26,8 +27,10 @@ export async function managedDirectory(directory, { create = false } = {}) {
   try {
     const info = await lstat(directory);
     if (!info.isDirectory() || info.isSymbolicLink()) throw new Error("managed directory is not a regular directory");
-    if (create) {
-      const handle = await open(directory, constants.O_RDONLY | constants.O_NOFOLLOW);
+    // Mode bits are POSIX privacy. Windows refuses fchmod on a directory
+    // handle, and privacy there is the profile ACL the directory inherits.
+    if (create && !isWindows()) {
+      const handle = await openNoFollow(directory, constants.O_RDONLY);
       try { await handle.chmod(0o700); } finally { await handle.close(); }
     }
     return true;
@@ -37,7 +40,11 @@ export async function managedDirectory(directory, { create = false } = {}) {
   }
 }
 
+/** Make removals and directory renames in `directory` durable. Windows refuses a
+ * flush on a directory handle; a record written by writeManagedJson is flushed
+ * itself there, and a removal that a power cut undoes only keeps a hold longer. */
 export async function syncDirectory(directory) {
+  if (isWindows()) return;
   const handle = await open(directory, constants.O_RDONLY | constants.O_NOFOLLOW);
   try { await handle.sync(); } finally { await handle.close(); }
 }
@@ -46,7 +53,7 @@ export async function syncDirectory(directory) {
 export async function readManagedJson(file) {
   let handle;
   try {
-    handle = await open(file, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    handle = await openNoFollow(file, constants.O_RDONLY | (constants.O_NONBLOCK ?? 0));
     if (!(await handle.stat()).isFile()) throw new Error("managed record must be a regular file");
     return JSON.parse(await handle.readFile("utf8"));
   } catch (error) {
@@ -55,17 +62,20 @@ export async function readManagedJson(file) {
   } finally { await handle?.close(); }
 }
 
-export async function writeManagedJson(file, value) {
+// `flushName: false` leaves the name to the next flush, for a record whose loss
+// on a crash is recovered by writing it again. The bytes are always flushed.
+export async function writeManagedJson(file, value, { flushName = true } = {}) {
   const temporary = path.join(path.dirname(file), `.record-${randomUUID()}.tmp`);
   let handle;
   try {
-    handle = await open(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL | constants.O_NOFOLLOW, 0o600);
+    handle = await openNoFollow(temporary, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL,
+      { mode: 0o600 });
     await handle.writeFile(`${JSON.stringify(value)}\n`);
     await handle.sync();
     await handle.close();
     handle = null;
-    await rename(temporary, file);
-    await syncDirectory(path.dirname(file));
+    await renameReplacing(temporary, file);
+    if (flushName) await syncEntry(path.dirname(file), file);
   } finally {
     await handle?.close();
     await rm(temporary, { force: true });

package/node_modules/@agents-can-communicate/cli/src/managed-runtime/worker.mjs

@@ -2,6 +2,7 @@ import { realpath } from "node:fs/promises";
 import path from "node:path";
 
 import { activatePending, reclaimGenerations } from "./activation.mjs";
+import { listRuntimeHolds } from "./leases.mjs";
 import { downloadRelease, fetchRelease, newerVersion } from "./download.mjs";
 import { withManagerLock } from "./mutex.mjs";
 import { readControl, writeControl, writeManagedJson } from "./state.mjs";
@@ -82,10 +83,24 @@ export async function reclaimAsActive(root, generationRoot) {
     const control = await readControl(root);
     if (control === null || await realpath(generationRoot) !== await realpath(control.active.root)) return;
     const result = await reclaimGenerations({ root });
-    // A postponed pass is recorded as unfinished, so the scheduler tries again
-    // (hourly) even with automatic updates off.
+    // The process that activated this generation still runs from the one it
+    // replaced, and its own lease keeps that generation through this pass -
+    // measured in the 0.8.5 upgrade preflight. That pass is unfinished, so the
+    // hourly retry removes the old generation once the process has exited. A
+    // worker started at once would race every command right after an update.
+    const active = await realpath(control.active.root);
+    const own = await listRuntimeHolds(root).then(async holds => {
+      for (const hold of holds) {
+        if (hold.pid === process.pid && await realpath(hold.runtime.root).catch(() => null) !== active) {
+          return true;
+        }
+      }
+      return false;
+    }, () => false);
+    // A postponed pass is recorded as unfinished too, so the scheduler tries
+    // again (hourly) even with automatic updates off.
     await writeManagedJson(path.join(root, RECLAIM_MARKER), { schemaVersion: 1,
-      activeRoot: control.active.root, complete: result?.postponed !== true,
+      activeRoot: control.active.root, complete: result?.postponed !== true && !own,
       attemptedAt: new Date().toISOString() });
   } catch { /* Best effort; the next pass reclaims again. */ }
 }

package/node_modules/@agents-can-communicate/cli/src/native-session-diagnostics.mjs

@@ -73,7 +73,12 @@ export async function updateNativeSessions(adapters, { service, status, root, no
         : binding === undefined ? "unbound"
           : delivery === null ? (leased ? "active" : "degraded")
             : !delivery.deliverable ? "degraded" : leased ? "active" : "idle";
+      // A session in another product the adapter serves - Antigravity 2.0
+      // beside Antigravity CLI - is named by that product.
+      const product = (byAdapterId.get(entry.adapterId)?.client?.variants ?? [])
+        .find(variant => variant?.certificationName === owner?.clientName);
       native.sessions.push({ sessionId: peer.sessionId, participantId: peer.participantId,
+        ...(product === undefined ? {} : { displayName: product.displayName }),
         presence: peer.presence, runtime, clientVersion: binding?.clientVersion ?? null, delivery,
         lastAttempt: owner === null ? null : await loadNativeAttempt({ runtimeDir: root, ...owner }) });
     }
@@ -104,9 +109,12 @@ const failures = {
   session_generation_stale: "the session was replaced during the handshake",
   workspace_identity_unavailable: "the bound client session is no longer in this workspace; "
     + "start a new client session here",
-  // It stays embedded until it closes; a later service never adopts it.
+  // It stays embedded until it closes; a later service never adopts it. The
+  // Codex app runs every chat this way (openai/codex#41014), so a new chat
+  // there is embedded too; one started in a terminal is not.
   client_session_embedded: "the client runs this session on its own embedded service, which "
-    + "peers cannot reach; start a new client session while its local delivery service runs",
+    + "peers cannot reach; start a new client session in a terminal while its local delivery "
+    + "service runs (the Codex app runs every chat embedded)",
 };
 
 function describeAttempt(attempt) {
@@ -120,7 +128,10 @@ function describeAttempt(attempt) {
         : attempt.policyStatus === "unavailable" ? `${source} delivery policy could not be read`
           : `${source} delivery policy was off`;
   } else if (attempt.state === "active") detail = "local handshake succeeded";
-  else detail = failures[attempt.reasonCode] ?? describeNativeReason(attempt.reasonCode);
+  else if (attempt.reasonCode === "client_session_embedded" && attempt.launchOption) {
+    detail = `${describeNativeReason(attempt.reasonCode, { launchOption: attempt.launchOption })}; `
+      + `start a new client session without ${attempt.launchOption}`;
+  } else detail = failures[attempt.reasonCode] ?? describeNativeReason(attempt.reasonCode);
   return `last attempt ${attempt.at}: ${detail}`;
 }
 
@@ -146,7 +157,7 @@ const RUNTIME_TEXT = { active: "local transport active", idle: "idle, lease laps
 
 export function nativeSessionLines(adapters) {
   return adapters.flatMap(entry => (entry.nativeDelivery.sessions ?? []).map(session =>
-    `  ${entry.displayName} session ${session.participantId} (${session.sessionId}): `
+    `  ${session.displayName ?? entry.displayName} session ${session.participantId} (${session.sessionId}): `
     + `${RUNTIME_TEXT[session.runtime] ?? session.runtime}; `
     + [describeDelivery(session), session.runtime === "idle" ? "the next send refreshes it" : null,
       describeAttempt(session.lastAttempt)].filter(part => part !== null).join("; ")));

package/node_modules/@agents-can-communicate/cli/src/platform-paths.mjs

@@ -28,15 +28,17 @@ const usage = (message, details) => {
   throw new AccError(EXIT.USAGE, message, details);
 };
 
+// Pids, locks and pipe names belong to one machine, so state and cache live in
+// local app data. A roaming profile would carry them to another machine, where
+// every recorded pid names something else; there is no roaming fallback.
 function windowsPaths(env) {
-  if (!set(env.APPDATA)) {
-    usage("cannot resolve the Windows application data directory");
+  if (!set(env.LOCALAPPDATA)) {
+    usage("cannot resolve the Windows local application data directory");
   }
   return {
-    data: env.APPDATA,
-    config: env.APPDATA,
-    // Roaming is the honest fallback: a cache that roams is wasteful, not wrong.
-    cache: set(env.LOCALAPPDATA) ? env.LOCALAPPDATA : env.APPDATA,
+    data: env.LOCALAPPDATA,
+    config: set(env.APPDATA) ? env.APPDATA : env.LOCALAPPDATA,
+    cache: env.LOCALAPPDATA,
   };
 }
 
@@ -45,18 +47,21 @@ function requireHome(env) {
   return env;
 }
 
+// POSIX paths are built with path.posix whatever the host: the resolution is a
+// pure function of platform and environment, and a Windows host would turn
+// every forward slash of a POSIX home into a backslash.
 function macosPaths(env) {
-  const support = path.join(env.HOME, "Library", "Application Support");
+  const support = path.posix.join(env.HOME, "Library", "Application Support");
   // XDG variables are deliberately ignored here. They are common on a machine
   // that also runs Linux tooling, and letting one relocate macOS state would
   // move a user's sessions the day they install something unrelated.
   return { data: support, config: support,
-    cache: path.join(env.HOME, "Library", "Caches") };
+    cache: path.posix.join(env.HOME, "Library", "Caches") };
 }
 
 function xdgPaths(env) {
-  const fallback = { data: path.join(env.HOME, ".local", "share"),
-    config: path.join(env.HOME, ".config"), cache: path.join(env.HOME, ".cache") };
+  const fallback = { data: path.posix.join(env.HOME, ".local", "share"),
+    config: path.posix.join(env.HOME, ".config"), cache: path.posix.join(env.HOME, ".cache") };
   return Object.fromEntries(AREAS.map(area =>
     [area, set(env[XDG[area]]) ? env[XDG[area]] : fallback[area]]));
 }

package/node_modules/@agents-can-communicate/cli/src/runtime-paths.mjs

@@ -54,9 +54,10 @@ export function platformDataHome({ platform = process.platform, env = process.en
   if (typeof env.ACC_DATA_HOME === "string" && env.ACC_DATA_HOME.length > 0) {
     return env.ACC_DATA_HOME;
   }
+  // Machine-local: see windowsPaths in platform-paths.mjs.
   if (platform === "win32") {
-    if (typeof env.APPDATA === "string" && env.APPDATA.length > 0) return env.APPDATA;
-    throw new AccError(EXIT.USAGE, "cannot resolve the Windows application data directory");
+    if (typeof env.LOCALAPPDATA === "string" && env.LOCALAPPDATA.length > 0) return env.LOCALAPPDATA;
+    throw new AccError(EXIT.USAGE, "cannot resolve the Windows local application data directory");
   }
   if (typeof env.XDG_DATA_HOME === "string" && env.XDG_DATA_HOME.length > 0
     && platform !== "darwin") {

package/node_modules/@agents-can-communicate/cli/src/update-command.mjs

@@ -2,6 +2,7 @@ import { execFile } from "node:child_process";
 import { mkdir, writeFile } from "node:fs/promises";
 import { promisify } from "node:util";
 
+import { pathOf, resolveExecutable, runExecutable } from "@agents-can-communicate/adapter-sdk";
 import { AccError, EXIT } from "@agents-can-communicate/protocol";
 
 import { platformPaths } from "./platform-paths.mjs";
@@ -11,6 +12,15 @@ import { runManagedUpdate, validateUpdateOptions } from "./managed-runtime/comma
 
 const execFileAsync = promisify(execFile);
 
+// npm and acc are .cmd shims on Windows: found through PATHEXT, and started
+// through cmd.exe. POSIX runs them by name as before.
+async function runStep(command, argv, env) {
+  if (process.platform !== "win32") return execFileAsync(command, argv, { env });
+  const file = await resolveExecutable(command, { pathEnv: pathOf(env) });
+  if (file === null) throw new Error(`${command} is not on PATH`);
+  return runExecutable(file, argv, { env });
+}
+
 /**
  * The two commands an upgrade takes, and why it is two.
  *
@@ -76,7 +86,7 @@ export async function runUpdateCommand({ options, runtime }) {
       ...steps.map(spell), "", "or run: acc update"].join("\n") };
   }
 
-  const spawn = runtime.spawn ?? ((command, argv) => execFileAsync(command, argv, { env }));
+  const spawn = runtime.spawn ?? ((command, argv) => runStep(command, argv, env));
   const done = [];
   let installation = { stdout: "", stderr: "" };
   for (const [command, argv] of steps) {

package/node_modules/@agents-can-communicate/cli/src/workspace-discovery.mjs

@@ -1,10 +1,11 @@
 import { createHash } from "node:crypto";
 import { constants } from "node:fs";
-import { open, realpath } from "node:fs/promises";
+import { realpath } from "node:fs/promises";
 import path from "node:path";
 
 import { AccError, CONFIG_FILENAME, EXIT, validateProjectConfig }
   from "@agents-can-communicate/protocol";
+import { openNoFollow } from "@agents-can-communicate/storage-filesystem";
 
 /**
  * @typedef {{ id: string, roots: string[], source: "config" | "git" | "directory",
@@ -17,7 +18,8 @@ const stableId = value =>
 async function readConfigNoFollow(configPath) {
   let handle;
   try {
-    handle = await open(configPath, constants.O_RDONLY | constants.O_NOFOLLOW);
+    // Windows has no O_NOFOLLOW; openNoFollow keeps the refusal there too.
+    handle = await openNoFollow(configPath, constants.O_RDONLY);
   } catch (error) {
     if (error.code === "ENOENT") return null;
     // ELOOP is what O_NOFOLLOW reports for a symlink. A config reached through