agents-can-communicate 0.8.1 → 0.8.2

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

@@ -7,7 +7,7 @@ import { createCodexAdapter } from "@agents-can-communicate/adapter-codex";
 import { createGeminiCliAdapter } from "@agents-can-communicate/adapter-gemini-cli";
 import { createGrokAdapter } from "@agents-can-communicate/adapter-grok";
 import { createKimiAdapter } from "@agents-can-communicate/adapter-kimi";
-import { applyPlan, detectInstallation, loadOwnership, planInstallation }
+import { applyPlan, detectInstallation, loadOwnership, planInstallation, receiverSockets }
   from "@agents-can-communicate/installer";
 import { AccError, EXIT } from "@agents-can-communicate/protocol";
 
@@ -28,7 +28,7 @@ export { decideDelivery } from "./install-delivery-consent.mjs";
 // pointed at the home itself writes beside them rather than inside them. That
 // install reports success and the client never reads a byte of it.
 export const clientContext = (home, stateRoot,
-  { env = {}, dataHome, cwd = process.cwd() } = {}) => ({
+  { env = {}, dataHome, cwd = process.cwd(), platform } = {}) => withReceivers({
   home,
   ...(dataHome === undefined ? {} : { dataHome }),
   configDir: path.join(home, ".claude"),
@@ -59,7 +59,14 @@ export const clientContext = (home, stateRoot,
   // roster and record nothing, every write failing with EPERM on the writer
   // lock. Measured with `codex exec`, which is how an agent actually runs.
   stateRoot,
-});
+}, platform);
+
+// Every socket ACC can deliver to, as each receiving adapter declares it, for
+// the one sender that sandboxes its shell: the Codex permission profile is
+// written and diagnosed from this list, so it covers Claude Code's inbox even
+// when an install names Codex alone (issue #213).
+const withReceivers = (context, platform) => ({ ...context,
+  receiverSockets: receiverSockets(ALL_ADAPTERS(), { ...context, platform }) });
 
 export const ALL_ADAPTERS = () => [createAntigravityAdapter(), createClaudeCodeAdapter(),
   createCodexAdapter(), createGeminiCliAdapter(), createGrokAdapter(), createKimiAdapter()];
@@ -222,7 +229,7 @@ export async function runInstallCommand({ options, runtime, action = "install" }
   const { data: dataHome } = platformPaths({ platform: runtime.platform,
     env: runtime.env ?? {} });
   const context = clientContext(home, path.join(dataHome, "acc"),
-    { env: runtime.env ?? {}, dataHome });
+    { env: runtime.env ?? {}, dataHome, platform: runtime.platform });
 
   const detected = await detectInstallation({ adapters, context,
     probeTimeoutMs: probeTimeout(runtime.env) });

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

@@ -16,7 +16,7 @@ const usage = message => new AccError(EXIT.USAGE, message);
 import { commandHelpText, describeCommand, describeCommands, helpText } from "./help.mjs";
 import { runUpdateCommand } from "./update-command.mjs";
 import { runConfigCommand } from "./config-command.mjs";
-import { runInstallCommand } from "./install-command.mjs";
+import { ALL_ADAPTERS, runInstallCommand } from "./install-command.mjs";
 import { runDoctor } from "./doctor-command.mjs";
 import { runManagementDoctor } from "./managed-runtime/diagnostics.mjs";
 import { createGitProbe } from "./git-probe.mjs";
@@ -179,12 +179,49 @@ export async function recordAndOffer({ record, router, selectMessage = value =>
   }
 }
 
-/** How many are here, and how many only look it. */
-export function describePresence({ live = 0, stale = 0 } = {}) {
+/**
+ * What a message sent to each stale session would meet.
+ *
+ * Presence reads the client process, so a dead one is offline and a stale
+ * session with a live process is idle. Idle is then told apart by delivery: a
+ * live binding wakes it, a client with next-turn delivery shows the message on
+ * its next turn, and anything else reads it through `acc inbox`. A session with
+ * no known process cannot be told from one that left, so it is not answering.
+ *
+ * A live binding wakes on the router's own rule: a current lease, or a lapsed
+ * one the adapter can re-verify. Without that the next send is durable.
+ */
+export function presenceBreakdown(participants = [], adapters = ALL_ADAPTERS()) {
+  const nextTurn = new Set(adapters.filter(adapter => adapter.capabilities?.delivery?.nextTurn === true)
+    .map(adapter => adapter.id));
+  const refreshes = new Set(adapters.filter(adapter => typeof adapter.refreshNativeSession === "function")
+    .map(adapter => adapter.id));
+  const wakes = participant => participant.liveDelivery === true
+    && (participant.liveLeaseCurrent === true || refreshes.has(participant.harness));
+  const idle = { wake: 0, nextTurn: 0, inbox: 0, unknown: 0 };
+  for (const participant of participants.filter(item => item.presence === "stale")) {
+    const kind = participant.processTracked !== true ? "unknown"
+      : wakes(participant) ? "wake"
+        : nextTurn.has(participant.harness) ? "nextTurn" : "inbox";
+    idle[kind] += 1;
+  }
+  return idle;
+}
+
+/**
+ * How many are here, and what a message would meet with those not active.
+ * Without a breakdown every stale session counts as not answering, the answer
+ * before presence could tell an idle session from one whose client had left.
+ */
+export function describePresence({ live = 0, stale = 0 } = {},
+  idle = { wake: 0, nextTurn: 0, inbox: 0, unknown: stale }) {
   if (live === 0) return "0 live";
   if (stale === 0) return `${live} live`;
-  if (stale === live) return `${live} present, none answering`;
-  return `${live} live (${stale} not answering)`;
+  if (idle.unknown === live) return `${live} present, none answering`;
+  const parts = [[idle.wake, "idle, wake on send"], [idle.nextTurn, "idle until next turn"],
+    [idle.inbox, "idle, inbox only"], [idle.unknown, "not answering"]]
+    .filter(([count]) => count > 0).map(([count, text]) => `${count} ${text}`);
+  return `${live} live (${parts.join("; ")})`;
 }
 
 export function describeStatus(status) {
@@ -193,7 +230,8 @@ export function describeStatus(status) {
   // stops being answered but does not disappear. Printing the number alone
   // said "1 live" about a workspace where the last agent had left minutes
   // before, which is the one thing a person reads this line to find out.
-  const line = `${describePresence(status.counts)}; ${status.counts.claims} claim(s); `
+  const line = `${describePresence(status.counts, presenceBreakdown(status.participants))}; `
+    + `${status.counts.claims} claim(s); `
     + `protection ${status.protection}`;
   // A transport accepting a message is not a model reading it. Said only when
   // it is true of something, so the everyday line stays the everyday line.

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

@@ -60,14 +60,19 @@ export async function updateNativeSessions(adapters, { service, status, root, no
         && b.availableModes.includes("livePush"));
       const off = native.policySource === "installation-record" && !native.configured;
       const leased = binding !== undefined && Date.parse(binding.leaseUntil) > Date.parse(now);
-      // Only where the old rule would have said "active": everywhere else the
-      // answer is already degraded or unbound, and a live check would buy
-      // nothing but a socket round trip.
-      const delivery = off || !leased ? null
+      // A lapsed lease is asked about too. Nothing renews it while a session
+      // sits idle, and the router does not refuse it: it re-verifies the
+      // receiver and refreshes the lease before it offers. Stopping at the
+      // lease reported sessions that answered a live question in seconds as
+      // degraded, with advice to start a new one.
+      const delivery = off || binding === undefined ? null
         : await verifyDelivery(byAdapterId.get(entry.adapterId), { binding, runtimeDir: root });
+      // Without a re-verification the router cannot refresh a lapsed lease
+      // either, so only a live lease keeps the old answer.
       const runtime = off ? "inactive"
         : binding === undefined ? "unbound"
-          : leased && (delivery === null || delivery.deliverable) ? "active" : "degraded";
+          : delivery === null ? (leased ? "active" : "degraded")
+            : !delivery.deliverable ? "degraded" : leased ? "active" : "idle";
       native.sessions.push({ sessionId: peer.sessionId, participantId: peer.participantId,
         presence: peer.presence, runtime, clientVersion: binding?.clientVersion ?? null, delivery,
         lastAttempt: owner === null ? null : await loadNativeAttempt({ runtimeDir: root, ...owner }) });
@@ -76,10 +81,13 @@ export async function updateNativeSessions(adapters, { service, status, root, no
     // one claiming health while nothing could be delivered. If this adapter
     // has bound sessions in this workspace and not one of them can take a
     // push, this is not an active transport.
-    if (native.runtime === "active" && native.sessions.length > 0
-      && !native.sessions.some(session => session.runtime === "active")) {
+    const reachable = native.sessions.some(session => ["active", "idle"].includes(session.runtime));
+    if (native.runtime === "active" && native.sessions.length > 0 && !reachable) {
       native.runtime = "degraded";
     }
+    // The other direction, which the binding pass cannot see: it reads a
+    // lapsed lease as unreachable, and a receiver that answered says otherwise.
+    if (native.runtime === "degraded" && reachable) native.runtime = "active";
   }
 }
 
@@ -131,10 +139,12 @@ function describeDelivery(session) {
     : "receiver verified";
 }
 
+const RUNTIME_TEXT = { active: "local transport active", idle: "idle, lease lapsed" };
+
 export function nativeSessionLines(adapters) {
   return adapters.flatMap(entry => (entry.nativeDelivery.sessions ?? []).map(session =>
     `  ${entry.displayName} session ${session.participantId} (${session.sessionId}): `
-    + `${session.runtime === "active" ? "local transport active" : session.runtime}; `
-    + [describeDelivery(session), describeAttempt(session.lastAttempt)]
-      .filter(part => part !== null).join("; ")));
+    + `${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/core/package.json

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

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

@@ -89,6 +89,12 @@ export function createStatusService(ports, sessions, deliveryBindings) {
     const claims = snapshot.claims
       .filter(claim => Date.parse(claim.expiresAt) > Date.parse(now));
     const currentBindings = await deliveryBindings.currentBindings(now);
+    // A live binding and its lease are reported apart. The router refreshes a
+    // lapsed lease only through the adapter's own re-verification, and which
+    // adapters have one is not a fact core may know, so the reader decides.
+    const liveBound = new Map(currentBindings
+      .filter(({ binding }) => binding.availableModes.includes("livePush"))
+      .map(({ binding, reachable }) => [binding.sessionId, reachable]));
     // What each recipient has not fetched yet, and how far it got. Offered is
     // not read: a transport took the bytes. Queued sits beside it so "0
     // offered" cannot be mistaken for "nothing waits". Replaced decisions
@@ -150,6 +156,12 @@ export function createStatusService(ports, sessions, deliveryBindings) {
         enforcement: session.enforcement ?? "advisory",
         lifecycle: session.lifecycle ?? "manual",
         presence,
+        // What a stale presence means depends on these. With the process known,
+        // stale is idle, since a dead process is offline; with a live binding,
+        // a push can wake it. Only a session nobody can observe is not answering.
+        processTracked: (session.pid ?? null) !== null,
+        liveDelivery: liveBound.has(session.sessionId),
+        liveLeaseCurrent: liveBound.get(session.sessionId) === true,
         // A finished intent reads as no intent at all. `--clear` exists so a
         // peer stops seeing work that has stopped, and reporting the summary of
         // a done record made the command and this line contradict each other.

package/node_modules/@agents-can-communicate/delivery-router/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/delivery-router",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "private": true,
   "type": "module",
   "exports": {

package/node_modules/@agents-can-communicate/hook-runner/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/hook-runner",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -602,6 +602,15 @@ const HANDLERS = {
   async beforeTool({ binding, context, event, adapter }) {
     if (binding === null) return { decision: "allow" };
     if (event.targets.length === 0) {
+      // A shell command is work too. The refresh below sat behind the write
+      // guard, so a turn spent in the shell went stale three minutes in, measured
+      // on 0.8.1. With no guard read to borrow from, the session's own record is
+      // the narrow read that says whether a heartbeat is due.
+      const own = await context.service.locateSession(binding.accSessionId).catch(() => null);
+      if (own !== null && needsRefresh(own.record.heartbeatAt, Date.now())) {
+        await context.service.heartbeatSession({ sessionId: binding.accSessionId,
+          generation: binding.generation }).catch(() => null);
+      }
       // The runner cannot tell what a shell command touches. Saying so is the
       // honest answer; guessing would block work at random and miss real writes.
       return { decision: "allow", unguarded: true };

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/installer",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "private": true,
   "type": "module",
   "exports": {

package/node_modules/@agents-can-communicate/installer/src/detect.mjs

@@ -31,8 +31,10 @@ const VERSION = /(?:^|[^0-9A-Za-z])v?(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)(?:\b
  * has: nothing is written, and a client that is not installed simply fails to
  * start.
  */
-export const spawnProbe = async (command, args) => {
-  const { stdout, stderr } = await run(command, args);
+// `env` decides where the command is looked up, so detection given an
+// environment finds the client on that environment's PATH.
+export const spawnProbe = async (command, args, { env } = {}) => {
+  const { stdout, stderr } = await run(command, args, env === undefined ? {} : { env });
   return `${stdout}${stderr}`.trim();
 };
 
@@ -122,8 +124,11 @@ export async function detectInstallation({ adapters, context, probe = spawnProbe
         const output = await withTimeout(
           // The declared binary, never the adapter id. Guessing the id made
           // every client whose command differs from it look uninstalled.
+          // On the PATH the native probes below use: a caller that passes its
+          // own environment must not find a different client, or none.
           Promise.resolve(probe(adapter.client.command,
-            adapter.client.versionArgs ?? ["--version"])),
+            adapter.client.versionArgs ?? ["--version"],
+            { env: context?.env === undefined ? undefined : { ...process.env, ...context.env } })),
           probeTimeoutMs, `${adapter.id} version probe`);
         if (typeof output === "string" && output !== "") {
           entry.present = true;
@@ -160,6 +165,8 @@ export async function detectInstallation({ adapters, context, probe = spawnProbe
         if (detected.blocked) entry.blocked = detected.blocked;
         if (detected.outgoingDelivery) entry.outgoingDelivery = detected.outgoingDelivery;
         if (detected.inboundDelivery) entry.inboundDelivery = detected.inboundDelivery;
+        // Whether the client asks before each ACC command, and what would stop it.
+        if (detected.commandApproval) entry.commandApproval = detected.commandApproval;
         if (detected.nativeSetup) entry.nativeSetup = detected.nativeSetup;
         entry.diagnostics = [...(detected.diagnostics ?? [])];
         // What a person has to do, as opposed to what is true. Adapters that

package/node_modules/@agents-can-communicate/installer/src/index.mjs

@@ -1,6 +1,7 @@
 // Detection, planning, application, and the record of what was installed.
 export { detectInstallation, spawnProbe } from "./detect.mjs";
 export { planInstallation } from "./plan.mjs";
+export { receiverSockets } from "./receiver-sockets.mjs";
 export { applyPlan } from "./apply.mjs";
 export { finalizeRemoval, fingerprint, loadOwnership, missingArtifactParents, recordInstall,
   removeEmptyOwnedDirectories, removeOwned, removeOwnedArtifacts, treeFingerprint, verifyOwned }

package/node_modules/@agents-can-communicate/installer/src/receiver-sockets.mjs

@@ -0,0 +1,19 @@
+import path from "node:path";
+
+/**
+ * Every Unix socket path ACC can deliver to on this machine.
+ *
+ * A sender whose client sandboxes its shell - Codex - has to be allowed to
+ * connect to the recipient's socket, and the recipient's adapter is the only
+ * one that knows where that socket lives. Each adapter declares its own through
+ * `inboundSockets(context)`; the sender's adapter receives the composed list as
+ * `context.receiverSockets` and never names another vendor's paths itself.
+ *
+ * Composed from every known adapter, not the ones an install names: installing
+ * Codex alone must still allow a Claude Code session installed before or after.
+ */
+export function receiverSockets(adapters, context) {
+  const paths = [...adapters].flatMap(adapter =>
+    typeof adapter.inboundSockets === "function" ? adapter.inboundSockets(context) ?? [] : []);
+  return [...new Set(paths.filter(item => typeof item === "string" && path.isAbsolute(item)))].sort();
+}

package/node_modules/@agents-can-communicate/mcp-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/mcp-server",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/protocol",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "private": true,
   "type": "module",
   "exports": {

package/node_modules/@agents-can-communicate/storage-filesystem/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/storage-filesystem",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "private": true,
   "type": "module",
   "exports": {

package/node_modules/@agents-can-communicate/storage-filesystem/src/atomic-json.mjs

@@ -64,7 +64,8 @@ async function replaceHandleBytes(handle, bytes) {
  * @returns {Promise<"published" | "already_published">}
  */
 export async function publishAtomic(destination, bytes,
-  { root, tmpDir, stageDir, replace = false, deadlineAt, afterAccepted }) {
+  { root, tmpDir, stageDir, replace = false, deadlineAt, afterAccepted, afterStageEnsured,
+    afterStageRenamed }) {
   assertPublicationDeadline(deadlineAt);
   // The accepted stage lives apart from the partial a failed publication
   // leaves, so what a file is follows from the directory it was created in
@@ -145,9 +146,8 @@ export async function publishAtomic(destination, bytes,
       // The seam the race test uses, in the manner retainFile already
       // establishes: the window this closes is invisible without one.
       await afterAccepted?.();
-      await ensureManagedDirectory(root, stageDir);
-      await rename(temporary, stage);
-      await syncDirectory(stageDir);
+      await retainAcceptedStage({ root, stageDir, temporary, stage, afterStageEnsured,
+        afterStageRenamed });
     } else {
       // A crash/error before immutable acceptance keeps its unique partial.
       // Retention avoids the unsafe parent-check/unlink pathname window, while
@@ -157,6 +157,32 @@ export async function publishAtomic(destination, bytes,
   }
 }
 
+// The sweep can take `stage` between any two of these steps: it renames the
+// directory aside, and a store still opening publishes here without the writer
+// mutex the sweep holds (CI on #217). The bytes are already published, so the
+// retained copy goes to whichever directory carries the name when it moves, and
+// a copy the sweep took along with the directory needs no sync here - the sweep
+// discards that directory. The two callbacks are seams for the race tests.
+const STAGE_RETRIES = 4;
+
+async function retainAcceptedStage({ root, stageDir, temporary, stage, afterStageEnsured,
+  afterStageRenamed }) {
+  for (let attempt = 0; ; attempt += 1) {
+    await ensureManagedDirectory(root, stageDir);
+    await afterStageEnsured?.();
+    try {
+      await rename(temporary, stage);
+      break;
+    } catch (error) {
+      if (error.code !== "ENOENT" || attempt >= STAGE_RETRIES) throw error;
+    }
+  }
+  await afterStageRenamed?.();
+  await syncDirectory(stageDir).catch(error => {
+    if (error.code !== "ENOENT") throw error;
+  });
+}
+
 // The opener is the seam the race tests use, and stays last so callers that do
 // not care never see it.
 export async function readJsonIfPresent(filePath, root, openFile) {

package/node_modules/@agents-can-communicate/storage-filesystem/src/safe-directory.mjs

@@ -29,32 +29,42 @@ function absolutePath(value, name, root = value) {
   return path.normalize(value);
 }
 
+// How many more times a create-mode check takes a directory that left its name
+// while being checked. The stage sweep renames `stage` aside and recreates it,
+// without regard to a store that is still opening beside it, so one more try is
+// the real case; the bound only stops a directory that never stays put from
+// holding its caller (CI on #217).
+const VANISHED_RETRIES = 4;
+
 async function inspectRealDirectory(directory, root, create) {
-  let details;
-  try {
-    details = await lstat(directory);
-  } catch (error) {
-    if (error.code === "ENOENT" && !create) throw error;
-    if (error.code !== "ENOENT") {
-      throw invalidDirectory("cannot inspect managed directory", directory, root, error.message);
-    }
+  for (let attempt = 0; ; attempt += 1) {
+    let details;
     try {
-      await mkdir(directory);
-    } catch (mkdirError) {
-      if (mkdirError.code !== "EEXIST") {
-        throw invalidDirectory("cannot create managed directory", directory, root,
-          mkdirError.message);
+      details = await lstat(directory);
+    } catch (error) {
+      if (error.code !== "ENOENT") {
+        throw invalidDirectory("cannot inspect managed directory", directory, root, error.message);
       }
+      // Missing again right after it was created means a rename took it.
+      if (!create || attempt > VANISHED_RETRIES) throw error;
+      try {
+        await mkdir(directory);
+      } catch (mkdirError) {
+        if (mkdirError.code !== "EEXIST") {
+          throw invalidDirectory("cannot create managed directory", directory, root,
+            mkdirError.message);
+        }
+      }
+      continue;
     }
-    details = await lstat(directory);
-  }
-  if (!details.isDirectory() || details.isSymbolicLink()) {
-    throw invalidDirectory("managed directory is not a real directory", directory, root);
+    if (!details.isDirectory() || details.isSymbolicLink()) {
+      throw invalidDirectory("managed directory is not a real directory", directory, root);
+    }
+    return details;
   }
-  return details;
 }
 
-async function inspectManagedDirectory(rootPath, directoryPath, create) {
+async function inspectManagedDirectory(rootPath, directoryPath, create, { afterInspect } = {}) {
   const root = absolutePath(rootPath, "managed root");
   const directory = absolutePath(directoryPath, "managed directory", root);
   const relative = relativeWithin(root, directory);
@@ -67,7 +77,17 @@ async function inspectManagedDirectory(rootPath, directoryPath, create) {
   let canonicalParent = canonicalRoot;
   for (const segment of relative.split(path.sep).filter(Boolean)) {
     current = path.join(current, segment);
-    details = await inspectRealDirectory(current, root, create);
+    let resolved;
+    for (let attempt = 0; ; attempt += 1) {
+      details = await inspectRealDirectory(current, root, create);
+      await afterInspect?.(current);
+      // A create-mode caller uses this name next. A directory renamed away
+      // between the check and the resolution leaves realpath nothing to resolve
+      // (ENOENT), so it is checked and created again, then resolved again; every
+      // check below applies to whichever attempt settles.
+      resolved = await resolveSegment(current, create && attempt < VANISHED_RETRIES);
+      if (resolved !== null) break;
+    }
     // realpath answers with the name the directory carries *now*, which is not
     // always the name that was asked for: on Darwin it resolves by opening the
     // path and asking the kernel for that vnode's current path, so a directory
@@ -86,7 +106,6 @@ async function inspectManagedDirectory(rootPath, directoryPath, create) {
     // swapped in under this name is not. ENOENT on the re-stat means it moved
     // again between the two calls, which cannot redirect anything: whatever
     // the caller opens through this path next fails the same way.
-    const resolved = await realpath(current);
     if (path.dirname(resolved) !== canonicalParent
       || (path.basename(resolved) !== segment
         && !await stillTheSameDirectory(details, resolved, current, root))) {
@@ -97,6 +116,16 @@ async function inspectManagedDirectory(rootPath, directoryPath, create) {
   return { directory, stat: details };
 }
 
+// null when the name went away and the caller may take it again.
+async function resolveSegment(current, retry) {
+  try {
+    return await realpath(current);
+  } catch (error) {
+    if (error.code === "ENOENT" && retry) return null;
+    throw error;
+  }
+}
+
 async function stillTheSameDirectory(details, resolved, current, root) {
   const served = await stat(resolved).then(found => found, error => {
     if (error.code === "ENOENT") return null;
@@ -105,10 +134,12 @@ async function stillTheSameDirectory(details, resolved, current, root) {
   return served === null || (served.dev === details.dev && served.ino === details.ino);
 }
 
-export async function assertManagedDirectory(rootPath, directoryPath) {
-  return inspectManagedDirectory(rootPath, directoryPath, false);
+// `afterInspect` is the seam the race tests use: it runs between a segment's
+// check and its resolution, the window a concurrent rename lands in.
+export async function assertManagedDirectory(rootPath, directoryPath, options) {
+  return inspectManagedDirectory(rootPath, directoryPath, false, options);
 }
 
-export async function ensureManagedDirectory(rootPath, directoryPath) {
-  return (await inspectManagedDirectory(rootPath, directoryPath, true)).directory;
+export async function ensureManagedDirectory(rootPath, directoryPath, options) {
+  return (await inspectManagedDirectory(rootPath, directoryPath, true, options)).directory;
 }

package/node_modules/@agents-can-communicate/storage-filesystem/src/store.mjs

@@ -121,8 +121,12 @@ export async function openFilesystemStore({ root, clock, ids, workspaceId, failA
   // must not roll the same journal forward concurrently.
   await recoverOpenJournals();
 
-  // Sweeping is a write, so it holds the same mutex recovery does and no
-  // publisher is in flight while the stage directory is detached. It is bounded
+  // Sweeping is a write, so it holds the same mutex recovery does, and no
+  // transaction publishes while the stage directory is detached. A store that is
+  // still opening beside it does: the identity record, the directory checks and
+  // the journal's first slot above run without the mutex, so the managed
+  // directory checks and publishAtomic take a `stage` that left its name once
+  // more rather than failing (CI on #217). It is bounded
   // per pass: a store carrying a large accumulation drains over several opens
   // rather than spending one hook's whole budget on it. The mutex is taken only
   // on the opens that actually sweep - see sweepIfDue, which decides before it

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-can-communicate",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "accManagedUpdateProtocol": 2,
   "accStoreVersion": 6,
   "type": "module",