agents-can-communicate 0.1.11 → 0.1.13

package/node_modules/@agents-can-communicate/adapter-claude-code/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/adapter-claude-code",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/adapter-codex",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/adapter-gemini-cli",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "private": true,
   "type": "module",
   "exports": {

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

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

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

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

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/cli",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -1,4 +1,4 @@
-import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";
 
@@ -156,9 +156,21 @@ async function diagnoseAdapters({ options, runtime }) {
 
 export async function runDoctor({ options, context, runtime }) {
   const root = context.paths.root;
-  const report = options.repair === true
-    ? await repairFilesystemStore({ root, clock: context.service.clock })
-    : await diagnoseFilesystemStore({ root });
+  // The clock comes from the context rather than through the service, because
+  // the service is what may not open: this command runs before anything reads a
+  // record, which is the whole point of it.
+  const clock = context.clock ?? context.service?.clock;
+  // A store that is not there yet is not an ambiguous one. Opening the workspace
+  // used to happen first and created it, so the inspection never saw this case;
+  // now that the diagnosis runs first, "no protocol.json" would read as
+  // "unreadable protocol.json" and a person's first `acc doctor` in a new
+  // project would answer that their store is broken.
+  const started = await stat(path.join(root, "protocol.json")).then(() => true, () => false);
+  const report = !started
+    ? { healthy: true, blocked: [], corrupt: [], repaired: [] }
+    : options.repair === true
+      ? await repairFilesystemStore({ root, clock })
+      : await diagnoseFilesystemStore({ root });
   const adapters = await diagnoseAdapters({ options, runtime });
   const { data: dataHome } = platformPaths({ platform: runtime?.platform,
     env: runtime?.env ?? {} });
@@ -166,7 +178,7 @@ export async function runDoctor({ options, context, runtime }) {
     ? await runtime.version().catch(() => null)
     : null;
   const update = await noticeUpdate({ dataHome, running, env: runtime?.env ?? {},
-    now: Date.parse(context.service.clock.now()), get: runtime?.fetch,
+    now: Date.parse(clock.now()), get: runtime?.fetch,
     io: { readFile, writeFile, mkdir } });
 
   // Before the store is read for anything else. `collectStatus` reads every
@@ -185,7 +197,11 @@ export async function runDoctor({ options, context, runtime }) {
         remediation: ["inspect blocked and corrupt paths before repairing"] });
   }
 
-  const status = await context.service.collectStatus({});
+  // Only now, and only because the report said the records can be read. A
+  // context built for this command opens the store on request rather than up
+  // front.
+  const service = context.service ?? await context.openService();
+  const status = await service.collectStatus({});
 
   const data = {
     workspaceId: context.descriptor.id,
@@ -210,6 +226,13 @@ export async function runDoctor({ options, context, runtime }) {
   // the store was healthy and nothing else.
   const text = [`store healthy; ${describePresence(status.counts)}; `
     + `protection ${status.protection}; ${installed} of ${adapters.length} adapter(s) installed`,
-  ...data.remediation.map(line => `  ${line}`)].join("\n");
+  ...data.remediation.map(line => `  ${line}`),
+  // `0 of 4` is a true line that reads as a broken machine, and on an
+  // MCP-only one it would read that way on every run forever. The server needs
+  // no adapter: measured answering `tools/list` and writing an intent on a
+  // machine with no client binaries on PATH at all.
+  ...(installed === 0
+    ? ["  no client is wired; any MCP client can still take part through acc-mcp"]
+    : [])].join("\n");
   return { data, text };
 }

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

@@ -125,6 +125,16 @@ export function describeOutcome({ action, acted, failed = [], skipped = [],
   // Said once, where it is needed: the reader has just been shown a list of
   // their own files with ACC's name in them.
   ...(action === "install" && acted > 0 ? ["", "undo with: acc uninstall"] : []),
+  // And said once where it is needed differently: an install that wired nothing
+  // has just told this reader four times that their machine is not supported.
+  // It is not - the MCP server needs no adapter, and was measured answering on a
+  // machine with no client binaries at all. Only when nothing was wired: the
+  // skips already carry their own remedy, and a line printed every time is a
+  // line that stops being read.
+  ...(action === "install" && acted === 0
+    ? ["", "no client was wired, but any MCP client can still take part: "
+      + "point it at the acc-mcp command"]
+    : []),
   ].join("\n");
 }
 

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

@@ -54,7 +54,14 @@ async function claimOn(options, context) {
   return mine[0].claimId;
 }
 
-async function openContext(options, runtime) {
+/**
+ * Where this workspace's state lives, without reading a byte of it.
+ *
+ * Split out because `doctor` is the command a person runs when the store cannot
+ * be read, and it has to know which store to look at before deciding whether
+ * looking is safe.
+ */
+async function locateContext(options, runtime) {
   const descriptor = await discoverWorkspace({
     cwd: options.cwd ?? runtime.cwd,
     env: runtime.env,
@@ -67,12 +74,37 @@ async function openContext(options, runtime) {
     workspaceId: descriptor.id,
     workspaceRoots: descriptor.roots,
   });
+  return { descriptor, paths };
+}
+
+async function withService({ descriptor, paths }, runtime) {
   const store = await openFilesystemStore({ root: paths.root, clock: runtime.clock,
     ids: runtime.ids, workspaceId: descriptor.id });
   return { descriptor, paths,
     service: createCoordinationService({ store, clock: runtime.clock, ids: runtime.ids }) };
 }
 
+async function openContext(options, runtime) {
+  return withService(await locateContext(options, runtime), runtime);
+}
+
+/**
+ * A context for the one command that has to survive an unopenable store.
+ *
+ * `runDoctor` already refused to read records before diagnosing them - fixed
+ * after a truncated file made it answer "invalid JSON record" while the
+ * inspection had already found the file and put it in a list nobody saw. The
+ * throw then moved earlier: opening the store happens before any handler runs,
+ * so one unreadable `protocol.json` killed the diagnosis a frame before the code
+ * written to report it. Here the store is opened on request, after the report
+ * has said that reading is safe.
+ */
+async function openDiagnosticContext(options, runtime) {
+  const located = await locateContext(options, runtime);
+  return { ...located, clock: runtime.clock,
+    openService: async () => (await withService(located, runtime)).service };
+}
+
 const human = value => (typeof value === "string" ? value : JSON.stringify(value, null, 2));
 
 /** How many are here, and how many only look it. */
@@ -368,7 +400,9 @@ export async function main(argv, runtime) {
     // and `help` has to answer in a directory that is no workspace at all.
     const context = NO_WORKSPACE.includes(parsed.command)
       ? null
-      : await openContext(parsed.options, runtime);
+      : parsed.command === "doctor"
+        ? await openDiagnosticContext(parsed.options, runtime)
+        : await openContext(parsed.options, runtime);
     // Which session is calling is answered once, here, rather than by each
     // handler: every one of them needs the same pair, and a handler that forgot
     // to ask would be an operation an agent cannot reach.

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/core",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "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.1.11",
+  "version": "0.1.13",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/installer",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "private": true,
   "type": "module",
   "exports": { ".": "./src/index.mjs" },

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/mcp-server",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "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.1.11",
+  "version": "0.1.13",
   "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.1.11",
+  "version": "0.1.13",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -32,9 +32,9 @@ export function encode(value) {
   return Buffer.from(`${serialised}\n`, "utf8");
 }
 
-async function bytesIfPresent(filePath, root) {
+async function bytesIfPresent(filePath, root, openFile) {
   try {
-    return await readRegularNoFollow(filePath, root);
+    return await readRegularNoFollow(filePath, root, openFile);
   } catch (error) {
     if (error.code === "ENOENT") return null;
     throw error;
@@ -87,8 +87,10 @@ export async function publishAtomic(destination, bytes, { root, tmpDir, replace
   }
 }
 
-export async function readJsonIfPresent(filePath, root) {
-  const bytes = await bytesIfPresent(filePath, root);
+// 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) {
+  const bytes = await bytesIfPresent(filePath, root, openFile);
   if (bytes === null) return null;
   try {
     return { value: JSON.parse(bytes.toString("utf8")), bytes };

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

@@ -22,9 +22,36 @@ function defaultPidIsAlive(pid) {
   }
 }
 
-async function readOwner(directory, root) {
-  const found = await readJsonIfPresent(path.join(directory, OWNER), root);
-  return found?.value ?? null;
+/**
+ * Who holds the lock, or nothing if it moved while we looked.
+ *
+ * Reads inside the store refuse a parent directory whose identity changed
+ * between the check and the open - the defence against a directory being
+ * swapped under a read. This lock is the one directory whose entire life is
+ * being created and removed: `mkdir` grants it, `rm` releases it, so its inode
+ * changes every time it passes from one process to the next. Reading its owner
+ * through the strict path meant a contended lock raised
+ * "record parent directory changed while opening" and the whole command failed -
+ * seen on Linux CI with four agents attaching to one fresh workspace, the
+ * ordinary way two people start work.
+ *
+ * Here that is not an anomaly, it is the answer: the lock moved. Null says so,
+ * and both callers already do the right thing with it - the acquiring loop waits
+ * and looks again, and the releasing branch declines to remove a directory that
+ * is no longer the one it created. The guard itself is untouched, and still
+ * refuses everywhere a parent has no business changing.
+ */
+async function readOwner(directory, root, openFile) {
+  try {
+    const found = await readJsonIfPresent(path.join(directory, OWNER), root, openFile);
+    return found?.value ?? null;
+  } catch (error) {
+    if (error instanceof AccError && error.code === EXIT.DATA
+      && /parent directory changed/.test(error.message)) {
+      return null;
+    }
+    throw error;
+  }
 }
 
 /**
@@ -58,7 +85,7 @@ async function takeStaleOwnership(directory, root, owner, now, pidIsAlive) {
 
 export async function withWriterMutex(paths, options, operation) {
   const { root, clock, pidIsAlive = defaultPidIsAlive, uuid = randomUUID,
-    attempts = 50, waitMs = 20 } = options;
+    attempts = 50, waitMs = 20, openFile } = options;
   const directory = path.join(paths.locks, "writer.lock");
   await ensureManagedDirectory(root, paths.locks);
   const token = uuid();
@@ -68,7 +95,7 @@ export async function withWriterMutex(paths, options, operation) {
       await mkdir(directory);
     } catch (error) {
       if (error.code !== "EEXIST") throw error;
-      const owner = await readOwner(directory, root);
+      const owner = await readOwner(directory, root, openFile);
       if (!await takeStaleOwnership(directory, root, owner, clock.now(), pidIsAlive)) {
         await new Promise(resolve => { setTimeout(resolve, waitMs); });
       }
@@ -79,7 +106,7 @@ export async function withWriterMutex(paths, options, operation) {
     try {
       return await operation();
     } finally {
-      const current = await readOwner(directory, root);
+      const current = await readOwner(directory, root, openFile);
       if (current?.token === token) await rm(directory, { recursive: true, force: true });
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-can-communicate",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "type": "module",
   "description": "Local-first coordination for independently opened AI agent sessions.",
   "keywords": [