agents-can-communicate 0.8.5 → 0.9.1

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

@@ -50,13 +50,66 @@ import { diagnoseFilesystemStore, repairFilesystemStore }
  *
  * Null for anything unreadable. "Might be old" on every run is not a diagnosis.
  */
+/**
+ * The package directory of the runner a shim or config names, or null.
+ *
+ * ACC writes the runner in double quotes in every form: a shell shim
+ * (`ACC_RUNNER="..."`), the Node shim Windows gets (a JSON string) and Kimi's
+ * config (a TOML string holding a command, whose own quotes are cmd's on
+ * Windows and TOML's elsewhere). Each quoted string is read the way a shell
+ * reads one: a backslash escapes only a quote, a backslash, $ or a backtick,
+ * which is all the shim escapes and all a path needs undone in JSON or TOML,
+ * so an unescaped C:\Users\... in a shell script stays that path. A string
+ * holding quotes is a command. A Windows path in it is cmd's, which has no
+ * escape character, so it is read as it stands and a UNC path keeps its leading
+ * \\; other words are read the shell's way, since Kimi's POSIX command escapes a
+ * quote in a path; then, when no word names the runner, the string is read
+ * whole, since a POSIX path may hold a quote.
+ * An apostrophe, as in C:\Users\O'Neil, is part of a path. An unquoted path is
+ * read to the whitespace before it.
+ */
+const RUNNER = /[\\/]agents-can-communicate(?=[\\/]bin[\\/]acc-hook\.mjs)/;
+const absoluteRoot = value => {
+  const match = RUNNER.exec(value);
+  if (match === null) return null;
+  const root = value.slice(0, match.index + match[0].length);
+  return /^(?:[A-Za-z]:)?[\\/]/.test(root) ? root : null;
+};
+
+const quotedStrings = text => [...text.matchAll(/"((?:[^"\\]|\\[\s\S])*)"/g)]
+  .map(([, quoted]) => quoted.replace(/\\(["\\$`])/g, "$1"));
+
+const commandRoot = command => {
+  for (const [, word] of command.matchAll(/"([^"]*)"/g)) {
+    const root = /^(?:[A-Za-z]:\\|\\\\)/.test(word) ? absoluteRoot(word) : null;
+    if (root !== null) return root;
+  }
+  for (const word of quotedStrings(command)) {
+    const root = absoluteRoot(word);
+    if (root !== null) return root;
+  }
+  return absoluteRoot(command);
+};
+
+export function runnerRoot(text) {
+  for (const value of quotedStrings(String(text))) {
+    const root = value.includes("\"") ? commandRoot(value) : absoluteRoot(value);
+    if (root !== null) return root;
+  }
+  const flat = String(text);
+  const match = RUNNER.exec(flat);
+  if (match === null) return null;
+  const start = flat.slice(0, match.index).search(/\S+$/);
+  return start < 0 ? null : absoluteRoot(flat.slice(start));
+}
+
 export async function wiredVersion(shimPath) {
   if (typeof shimPath !== "string" || shimPath === "") return null;
   const text = await readFile(shimPath, "utf8").catch(() => null);
   if (text === null) return null;
-  const runner = /["']?(\/[^"'\s]*\/agents-can-communicate)\/bin\/acc-hook\.mjs["']?/.exec(text);
-  if (runner === null) return null;
-  const manifest = await readFile(path.join(runner[1], "package.json"), "utf8")
+  const root = runnerRoot(text);
+  if (root === null) return null;
+  const manifest = await readFile(path.join(root, "package.json"), "utf8")
     .catch(() => null);
   if (manifest === null) return null;
   try {
@@ -103,7 +156,10 @@ async function findShims(root, depth) {
   for (const entry of entries) {
     const target = path.join(root, entry.name);
     if (entry.isDirectory()) found.push(...await findShims(target, depth - 1));
-    else if (entry.name.endsWith(".sh")) found.push(target);
+    // The shell shim on POSIX, the Node shim on Windows.
+    else if (/^acc-(?:hook|cli)\.(?:sh|mjs)$/.test(entry.name) || entry.name.endsWith(".sh")) {
+      found.push(target);
+    }
   }
   return found;
 }

package/node_modules/@agents-can-communicate/cli/src/hook-support.mjs

@@ -0,0 +1,9 @@
+// What a hook needs from this package, without the rest of it. A hook starts a
+// process on every turn, and the package index loads the whole command line and
+// the installer with it: modules a hook never runs, about a millisecond each on
+// windows-latest.
+export { resolveHookWorkspace } from "./hook-workspace.mjs";
+export { createGitProbe } from "./git-probe.mjs";
+export { platformDataHome, runtimePaths } from "./runtime-paths.mjs";
+export { clearPin, hookEntrypointFor, resolvePinnedGeneration, writePin }
+  from "./managed-runtime/pins.mjs";

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

@@ -12,7 +12,7 @@ import { runtimePaths } from "./runtime-paths.mjs";
 // this survives client exit: resuming the same native conversation keeps its
 // room. Adapter + native id distinguish independent conversations.
 export async function resolveHookWorkspace({ adapterId, event, room, cwd, dataHome, env = {},
-  gitProbe, clock, deadlineAt }) {
+  gitProbe, clock, deadlineAt, platform = process.platform }) {
   const identityKey = (adapter, native) => createHash("sha256")
     .update(JSON.stringify([adapter, native])).digest("hex");
   if (room !== undefined && !/^[a-f0-9]{64}$/.test(room)) {
@@ -72,7 +72,13 @@ export async function resolveHookWorkspace({ adapterId, event, room, cwd, dataHo
     let current = descriptor;
     if (descriptor.source === "git" && path.resolve(event.cwd) !== workspaceCwd) {
       const git = await gitProbe({ cwd: event.cwd }).catch(() => null);
-      if (git !== null && await realpath(git.commonDir) === descriptor.git.commonDir) {
+      // Both sides canonical: Git spells the directory the way the cwd did
+      // (through a symlink, or `C:/…` on Windows), and the room kept that
+      // spelling.
+      const same = git !== null && await Promise.all([git.commonDir, descriptor.git.commonDir]
+        .map(directory => realpath(directory).catch(() => null)))
+        .then(([here, room]) => here !== null && here === room);
+      if (same) {
         current = { ...descriptor, git };
       }
     }
@@ -97,13 +103,16 @@ export async function resolveHookWorkspace({ adapterId, event, room, cwd, dataHo
       const raced = await read();
       if (raced !== null) return discover(raced);
       deadline();
+      // On Windows the session this hook opens next flushes, and that commits
+      // this name with NTFS's journal; a crash before it leaves the room to be
+      // chosen again by the session's next hook.
       await writeManagedJson(file, { schemaVersion: 1, adapterId,
         nativeSessionId: event.sessionId, cwd: context.workspaceCwd,
         workspaceId: context.descriptor.id, source: context.descriptor.source,
         ...(context.descriptor.source === "git" ? { git: {
           commonDir: await realpath(context.descriptor.git.commonDir),
           worktreeRoot: await realpath(context.descriptor.git.worktreeRoot),
-        } } : {}) });
+        } } : {}) }, { flushName: platform !== "win32" });
       return { ...context, workspaceRef: `acc://${key}` };
     });
 }

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

@@ -1,5 +1,5 @@
 import { createHash } from "node:crypto";
-import { readdir, rm } from "node:fs/promises";
+import { readdir } from "node:fs/promises";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { assertPortableId } from "@agents-can-communicate/protocol";
@@ -8,6 +8,7 @@ import { listRuntimeHolds } from "./leases.mjs";
 import { confirmedDead, defaultPidIsAlive, withManagerLock } from "./mutex.mjs";
 import { reapPins } from "./pins.mjs";
 import { reapStagingHolds } from "./staging.mjs";
+import { removeTree } from "./portable-fs.mjs";
 import { canonicalManagerRoot, managedDirectory, readControl, readManagedJson, syncDirectory, writeControl } from "./state.mjs";
 
 /** The staged generation states its own contract in its manifest, so the
@@ -250,7 +251,7 @@ export async function reclaimGenerations({ root, active = null, pidIsAlive = def
       if (!entry.isDirectory() || entry.name.startsWith(".")) continue;
       const directory = path.join(generations, entry.name);
       if (referenced.has(directory)) continue;
-      await rm(directory, { recursive: true, force: true });
+      await removeTree(directory);
       removed.push(entry.name);
     }
     if (removed.length) await syncDirectory(generations);

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/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("; ")));