agents-can-communicate 0.8.5 → 0.9.0

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/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) {
@@ -149,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

package/node_modules/@agents-can-communicate/core/package.json

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

package/node_modules/@agents-can-communicate/core/src/delivery-bindings.mjs

@@ -91,6 +91,13 @@ export function createDeliveryBindingService(ports, sessions) {
   async function clearDeliveryBinding(input) {
     const { sessionId, generation } = input;
     const endpointScoped = Object.hasOwn(input, "opaqueEndpointRef");
+    // Every hook clears when live delivery is not running, and on Windows that
+    // is every hook. Absent, or retired for this generation, is a state the
+    // update below leaves exactly as it is, so it is read first without the
+    // writer lock; a record read this way is as current as one read under it.
+    const seen = await store.ephemeral.get("deliveryBinding", sessionId);
+    if (seen === null || seen === undefined) return;
+    if (seen.generation === generation && seen.retiredAt !== null && seen.retiredAt !== undefined) return;
     await store.ephemeral.update("deliveryBinding", sessionId, async current => {
       if (current === null || current === undefined) return null;
       if (current.generation !== generation) throw conflict(sessionId);

package/node_modules/@agents-can-communicate/core/src/materialisation.mjs

@@ -21,9 +21,19 @@ export async function isMaterialised(store, workspaceId) {
   return (await store.snapshot(workspaceId, { kinds: ["workspace"] })).workspace !== null;
 }
 
-export async function materialise({ store, clock, ids }, { workspaceId, descriptor, reason }) {
+/**
+ * `opening` is a second live session that opens here, in the transaction that
+ * materialises, instead of first writing an ephemeral copy of itself to be
+ * copied and retired a moment later. It opens only while the session it joins
+ * is still live under the lock; otherwise it would be a lone session, which
+ * leaves no durable trace, and nothing is written: the result is false and the
+ * caller opens it ephemerally.
+ */
+export async function materialise({ store, clock, ids },
+  { workspaceId, descriptor, reason, opening = null }) {
   const now = clock.now();
   const staged = [];
+  let joined = true;
 
   await store.transaction(async tx => {
     // Ephemeral writers use this same mutex. Reading before taking it could
@@ -31,6 +41,13 @@ export async function materialise({ store, clock, ids }, { workspaceId, descript
     for (const entry of EPHEMERAL_KINDS) {
       staged.push({ ...entry, records: await store.ephemeral.list(entry.kind) });
     }
+    if (opening !== null && tx.get("workspace", workspaceId) === null
+      && !staged.find(entry => entry.kind === "session").records.some(record =>
+        record.state === "open" && record.sessionId !== opening.session.sessionId)) {
+      joined = false;
+      staged.length = 0;
+      return;
+    }
     const actorSessionId = staged.find(entry => entry.kind === "session")?.records.at(-1)?.sessionId
       ?? "session_bootstrap";
     // Asked again inside the lock. `ensureMaterialised` asks before taking it,
@@ -53,8 +70,14 @@ export async function materialise({ store, clock, ids }, { workspaceId, descript
         payload: { reason } });
     }
 
+    // The opening session's own ephemeral copy - left by a process that died
+    // mid-open - is what the opening replaces, not a session to promote first:
+    // promoting it would record the session opening twice.
+    const own = opening === null ? null : staged.find(entry => entry.kind === "session")
+      .records.find(record => record.sessionId === opening.session.sessionId) ?? null;
     for (const entry of staged) {
       for (const record of entry.records) {
+        if (record === own) continue;
         // Whoever got here first may have promoted this record already, and
         // promoting is a copy: the ephemeral and durable shapes are the same,
         // so the one already there is the one this would write.
@@ -66,11 +89,25 @@ export async function materialise({ store, clock, ids }, { workspaceId, descript
           payload: { sessionId: record.sessionId } });
       }
     }
+
+    if (opening !== null) {
+      const { participant, session } = opening;
+      const current = tx.get("session", session.sessionId) ?? own;
+      opening.assertAvailable(current);
+      if (tx.get("participant", participant.participantId) === null) {
+        tx.put("participant", participant.participantId, participant);
+      }
+      tx.put("session", session.sessionId, session, tx.generationOf("session", session.sessionId));
+      tx.append({ schemaVersion: SCHEMA_VERSION, eventId: ids.next("event"), workspaceId,
+        actorSessionId: session.sessionId, type: "session.opened", occurredAt: now,
+        payload: { replaced: current?.generation ?? null } });
+    }
   // The promoted kinds are named by the loop above, not written literally in
   // the body, so they are derived rather than repeated: a new ephemeral kind
   // added to that list is read here without anyone remembering to say so.
   }, { kinds: ["workspace", ...EPHEMERAL_KINDS.map(entry => entry.kind)] });
 
+  if (!joined) return false;
   // The ephemeral copies are retired only after the durable transaction
   // committed, so a crash in between leaves a recoverable duplicate rather than
   // a hole.
@@ -79,6 +116,7 @@ export async function materialise({ store, clock, ids }, { workspaceId, descript
       await store.ephemeral.delete(entry.kind, record[entry.key]);
     }
   }
+  return true;
 }
 
 export async function ensureMaterialised(ports, { workspaceId, descriptor, reason }) {