agents-can-communicate 0.1.8 → 0.1.10

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.8",
+  "version": "0.1.10",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -1,5 +1,4 @@
 {
   "name": "agents-can-communicate",
-  "version": "0.1.6",
   "description": "Coordinate this Claude Code session with other AI agent sessions working in the same workspace: shared presence, resource claims, typed messages, and handoffs."
 }

package/node_modules/@agents-can-communicate/adapter-claude-code/src/install.mjs

@@ -1,10 +1,11 @@
-import { cp, mkdir, readFile, rm, writeFile } from "node:fs/promises";
+import { cp, mkdir, readdir, readFile, rm, writeFile } from "node:fs/promises";
 import path from "node:path";
 
 import { AccError, EXIT } from "@agents-can-communicate/protocol";
 import { fileURLToPath } from "node:url";
 
 import { acccreatedFile, bakeSkillCommand, blankJson, mergeOwnedEntries, ownedEntries,
+  keepOnlyVersion, ownVersion, stampPluginVersion,
   removeIfEmpty,
   removeInstalledTree,
   removeOwnedEntries, writeForeignJson, writeHookShim }
@@ -122,7 +123,9 @@ const writeRegistry = async (file, value, remaining) => {
   return rm(file, { force: true });
 };
 
-const pluginVersion = async () => (await readJson(manifest, {})).version ?? "0.0.0";
+// One version on this machine: the package's own. The shipped manifest carries
+// none, so there is nothing in the repository to fall out of step.
+const pluginVersion = async () => ownVersion(import.meta.url);
 
 /** The marketplace manifest, in the shape the client's own directory sources use. */
 const marketplaceManifest = () => ({
@@ -147,6 +150,11 @@ async function layOutPlugin(target, { runner, node }) {
   // The bundle's hooks.json names this script, and nothing else writes it.
   await writeHookShim({ dir: path.join(target, "hooks"), adapterId: "claude_code",
     runner, node });
+  // The copy the client reads says which ACC wrote it. The shipped manifest
+  // carries no version, so there is nothing in the repository to fall out of
+  // step - which is how every client came to report 0.1.6 while running 0.1.9.
+  await stampPluginVersion({ file: path.join(target, ".claude-plugin", "plugin.json"),
+    version: await pluginVersion(), io: { readFile, writeFile } });
 }
 
 export async function installClaudePlugin({ configDir, runner, node, now = new Date() }) {
@@ -172,6 +180,11 @@ export async function installClaudePlugin({ configDir, runner, node, now = new D
   // run `claude plugin install`, exactly as the Codex adapter does, because the
   // command's only effect is this copy plus the two registry entries below.
   await layOutPlugin(cached, { runner, node });
+  // One copy, the one just written. A client caches a plugin under its version,
+  // so every upgrade would otherwise leave the previous release's tree beside
+  // this one - invisible while the version never moved, three deep once it did.
+  await keepOnlyVersion({ root: path.dirname(cached), version,
+    io: { readdir, rm } });
 
   await writeClientJson(knownMarketplacesPath(configDir), {
     ...known,

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

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

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

@@ -1,9 +1,13 @@
 {
   "name": "agents-can-communicate",
-  "version": "0.1.6",
   "description": "Coordinate this Codex session with other AI agent sessions working in the same workspace.",
   "license": "UNLICENSED",
-  "keywords": ["coordination", "multi-agent", "claims", "handoff"],
+  "keywords": [
+    "coordination",
+    "multi-agent",
+    "claims",
+    "handoff"
+  ],
   "skills": "./skills/",
   "hooks": "./hooks.json",
   "interface": {
@@ -12,6 +16,9 @@
     "longDescription": "Attaches this session to a local coordination plane shared with Codex, Claude Code, Gemini CLI, and MCP clients working in the same workspace. Publishes what this session is doing, warns before two sessions edit the same resource, carries typed messages between participants, and records a handoff at the end.",
     "developerName": "automatis-tools",
     "category": "Developer Tools",
-    "capabilities": ["Read", "Write"]
+    "capabilities": [
+      "Read",
+      "Write"
+    ]
   }
 }

package/node_modules/@agents-can-communicate/adapter-codex/src/install.mjs

@@ -1,8 +1,9 @@
-import { cp, mkdir, readFile, rm, rmdir, stat, writeFile } from "node:fs/promises";
+import { cp, mkdir, readdir, readFile, rm, rmdir, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
 import { bakeSkillCommand, blankJson, blankText, removeIfEmpty, removeInstalledTree,
+  keepOnlyVersion, ownVersion, stampPluginVersion,
   removeTomlBlock, stripBlock, tomlString,
   writeForeignJson, writeHookShim, writeTomlBlock }
   from "@agents-can-communicate/adapter-sdk";
@@ -199,11 +200,19 @@ export async function installCodexPlugin({ home, agentsHome = home,
 
   // The client runs the cached copy, so this has to happen after the shim and
   // the rewritten hooks.json are in place.
-  const { version } = await readJson(
-    path.join(target, ".codex-plugin", "plugin.json"), { version: "0.0.0" });
+  // One version on this machine: the package's own. The shipped manifest carries
+  // none, so nothing in the repository can fall out of step with it - which is
+  // how every client came to report 0.1.6 while running 0.1.9. The copy the
+  // client reads is stamped, so it says which ACC wrote it.
+  const version = await ownVersion(import.meta.url);
+  await stampPluginVersion({ file: path.join(target, ".codex-plugin", "plugin.json"),
+    version, io: { readFile, writeFile } });
   const cached = cachedVersionPath(codexHome, version);
   await rm(cached, { recursive: true, force: true });
   await cp(target, cached, { recursive: true });
+  // One copy, the one just written - and only inside this plugin's own
+  // directory. The marketplace cache root above it holds other people's plugins.
+  await keepOnlyVersion({ root: path.dirname(cached), version, io: { readdir, rm } });
 
   // The plugin's own directory in the cache. Not the versioned one inside it,
   // which goes stale the moment the version changes - and not the marketplace

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.8",
+  "version": "0.1.10",
   "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.8",
+  "version": "0.1.10",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -1,6 +1,5 @@
 {
   "name": "agents-can-communicate",
-  "version": "0.1.6",
   "description": "Coordinate this Kimi Code session with other AI agent sessions working in the same workspace: shared presence, resource claims, typed messages, and handoffs.",
   "skills": "./skills/",
   "sessionStart": {

package/node_modules/@agents-can-communicate/adapter-kimi/src/install.mjs

@@ -5,6 +5,7 @@ import { AccError, EXIT } from "@agents-can-communicate/protocol";
 import { fileURLToPath } from "node:url";
 
 import { assertRunner, bakeSkillCommand, blankText, defaultRunner, removeIfEmpty,
+  ownVersion, stampPluginVersion,
   removeInstalledTree, runnerExists, writeForeignJson }
   from "@agents-can-communicate/adapter-sdk";
 
@@ -132,6 +133,10 @@ export async function installKimiPlugin({ home, runner = defaultRunner(), node }
   const target = pluginPath(home);
   await rm(target, { recursive: true, force: true });
   await cp(bundle, target, { recursive: true });
+  // The copy this client reads says which ACC wrote it. Nothing here reads it
+  // back, but a manifest that names a version it is not is a lie either way.
+  await stampPluginVersion({ file: path.join(target, ".kimi-plugin", "plugin.json"),
+    version: await ownVersion(import.meta.url), io: { readFile, writeFile } });
   // The skill ships with a placeholder where the command belongs: `acc` is
   // not on PATH everywhere, and an agent that cannot run it improvises.
   await bakeSkillCommand({ root: target, node });

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

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

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

@@ -9,6 +9,7 @@ export { BEGIN, END, removeTomlBlock, renderBlock, stripBlock, tomlString, write
   from "./toml-block.mjs";
 export { projectContext } from "./context-projector.mjs";
 export { shellWriteTargets } from "./shell-writes.mjs";
+export { keepOnlyVersion, ownVersion, stampPluginVersion } from "./own-version.mjs";
 export { editJson, readJson } from "./json-text.mjs";
 export { formatJsonAs, jsonStyleOf, mergeOwnedConfig, mergeOwnedEntries, ownedEntries, ownedKeys,
   acccreatedFile, removeIfEmpty, removeOwnedConfig, removeOwnedEntries, writeForeignJson,

package/node_modules/@agents-can-communicate/adapter-sdk/src/own-version.mjs

@@ -0,0 +1,81 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+/**
+ * The version of the ACC that is running.
+ *
+ * Every plugin manifest used to carry its own version literal, updated by hand
+ * and by nobody: three releases after 0.1.6 the package was 0.1.9 while every
+ * client had cached, listed and reported 0.1.6. That is not cosmetic - the
+ * version string is how a client decides whether its cached copy is current, so
+ * a bundle whose version never changes is one it has no reason to replace.
+ *
+ * Read by walking up for the nearest `package.json`, which lands on the calling
+ * package in a checkout and on the same file once bundled, where every package
+ * is versioned together. Answers `0.0.0` rather than throwing: an install that
+ * cannot read its own version should still lay a plugin down, under a version
+ * that is visibly wrong rather than crash.
+ */
+export async function ownVersion(fromUrl) {
+  let directory = path.dirname(fileURLToPath(fromUrl));
+  for (;;) {
+    const candidate = path.join(directory, "package.json");
+    const text = await readFile(candidate, "utf8").catch(() => null);
+    if (text !== null) {
+      try {
+        const version = JSON.parse(text).version;
+        if (typeof version === "string" && version !== "") return version;
+      } catch {
+        // A manifest that will not parse is not this package's version.
+      }
+    }
+    const parent = path.dirname(directory);
+    if (parent === directory) return "0.0.0";
+    directory = parent;
+  }
+}
+
+/**
+ * Stamp a laid-out plugin manifest with the version that wrote it.
+ *
+ * The shipped manifest carries no version of its own, so there is nothing in the
+ * repository to fall out of step. Best-effort: a manifest that is not there was
+ * not ours to stamp.
+ */
+export async function stampPluginVersion({ file, version, io }) {
+  const text = await io.readFile(file, "utf8").catch(() => null);
+  if (text === null) return false;
+  let manifest;
+  try {
+    manifest = JSON.parse(text);
+  } catch {
+    return false;
+  }
+  await io.writeFile(file, `${JSON.stringify({ ...manifest, version }, null, 2)}\n`);
+  return true;
+}
+
+/**
+ * Leave one copy of a versioned plugin, the one just written.
+ *
+ * These clients cache a plugin under its version. Until the version tracked the
+ * package it never changed, every install landed in the same directory and
+ * overwrote itself, and nothing accumulated. Once it started moving, the first
+ * upgrade left three copies of ACC in a home that should hold one.
+ *
+ * Scoped to the plugin's own directory. The marketplace cache root above it
+ * holds every plugin installed from that marketplace, and removing that root
+ * once took a plugin the user had installed themselves - so a sibling here is
+ * an older ACC, and a sibling one level up is somebody else's.
+ */
+export async function keepOnlyVersion({ root, version, io }) {
+  const entries = await io.readdir(root, { withFileTypes: true }).catch(() => []);
+  const removed = [];
+  for (const entry of entries) {
+    if (!entry.isDirectory() || entry.name === version) continue;
+    await io.rm(path.join(root, entry.name), { recursive: true, force: true });
+    removed.push(entry.name);
+  }
+  return removed;
+}

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

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

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

@@ -63,7 +63,10 @@ export const COMMANDS = Object.freeze({
   // No `--yes`: neither of these ever asked, so the flag agreed to nothing. It
   // was accepted and read by nobody, which is a promise that a confirmation
   // exists to be skipped.
-  install: { required: [], optional: ["adapter", "home"], flags: ["dry-run"] },
+  // `--downgrade` because an older acc first on PATH will otherwise rewire every
+  // client to itself, and the only symptom is a guard behaving like the version
+  // it came from.
+  install: { required: [], optional: ["adapter", "home"], flags: ["dry-run", "downgrade"] },
   // `--dry-run` on both, because the preview was computed for either action and
   // only `install` could ask for it. Removal is the side that reaches into a
   // client's configuration - including a client that has left the machine.

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

@@ -1,4 +1,4 @@
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";
 
@@ -30,11 +30,77 @@ import { diagnoseFilesystemStore, repairFilesystemStore }
  * Unknown when the install predates the record carrying it, and then nothing is
  * said: "your plugin might be old" on every run is not a diagnosis.
  */
+/**
+ * The ACC version a client will actually run, read out of its own shim.
+ *
+ * `staleInstall` compares the version recorded at install time against the one
+ * running now. That holds until the thing that rewrote the wiring is an ACC old
+ * enough not to know the field: an 0.1.1 first on PATH for one install rewired
+ * four clients to itself and rewrote the record with `accVersion: null`, erasing
+ * the evidence along with the wiring. The record is written by whoever writes
+ * last; the shim carries the absolute path of the runner the client executes,
+ * and an old ACC writes it honestly, pointing at itself.
+ *
+ * Null for anything unreadable. "Might be old" on every run is not a diagnosis.
+ */
+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")
+    .catch(() => null);
+  if (manifest === null) return null;
+  try {
+    const version = JSON.parse(manifest).version;
+    return typeof version === "string" ? version : null;
+  } catch {
+    return null;
+  }
+}
+
 export function staleInstall({ recorded, running }) {
   if (typeof recorded !== "string" || typeof running !== "string") return null;
   return recorded === running ? null : { recorded, running };
 }
 
+/**
+ * The runner version behind whatever ACC wrote for one client.
+ *
+ * Two shapes, because the four clients differ: a config file ACC merged its hook
+ * commands into, and a tree ACC created with a shim inside it. The first
+ * readable answer wins, and every read is best-effort - a doctor that throws on
+ * a missing file diagnoses nothing.
+ */
+async function wiredVersionFor(artifacts) {
+  for (const artifact of artifacts ?? []) {
+    if (artifact.kind === "tree") {
+      for (const shim of await findShims(artifact.path, 4)) {
+        const version = await wiredVersion(shim);
+        if (version !== null) return version;
+      }
+      continue;
+    }
+    const version = await wiredVersion(artifact.path);
+    if (version !== null) return version;
+  }
+  return null;
+}
+
+/** Shim files under a tree ACC created, to a bounded depth. */
+async function findShims(root, depth) {
+  if (depth < 0) return [];
+  const entries = await readdir(root, { withFileTypes: true }).catch(() => []);
+  const found = [];
+  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);
+  }
+  return found;
+}
+
 async function diagnoseAdapters({ options, runtime }) {
   // The same home `acc install --home` writes to, or the real one. Reading a
   // different home than install wrote to reports every adapter as missing.
@@ -64,16 +130,24 @@ async function diagnoseAdapters({ options, runtime }) {
     if (owned.missing.length > 0) {
       remediation.push(`acc install --adapter ${entry.adapterId}  # files are missing`);
     }
-    const stale = staleInstall({
-      recorded: record.installs.find(install => install.adapterId === entry.adapterId)
-        ?.accVersion ?? null,
-      running });
+    const installed = record.installs.find(one => one.adapterId === entry.adapterId);
+    const stale = staleInstall({ recorded: installed?.accVersion ?? null, running });
     if (stale !== null) {
       remediation.push(`acc install --adapter ${entry.adapterId}`
         + `  # plugin is ${stale.recorded}, acc is ${stale.running}`);
     }
-    return { ...entry, stale, owned: { modified: owned.modified, missing: owned.missing,
-      intact: owned.intact.length }, remediation };
+    // Read from the wiring rather than from the record. An ACC old enough not to
+    // know the record's version field still rewrites that record - blank - while
+    // pointing every client at itself, so the record goes quiet exactly when it
+    // matters. The shim names the runner the client will execute.
+    const wired = await wiredVersionFor(installed?.artifacts);
+    if (stale === null && typeof wired === "string" && typeof running === "string"
+      && wired !== running) {
+      remediation.push(`acc install --adapter ${entry.adapterId}`
+        + `  # wired to acc ${wired}, this is ${running}`);
+    }
+    return { ...entry, stale, wired, owned: { modified: owned.modified,
+      missing: owned.missing, intact: owned.intact.length }, remediation };
   }));
 }
 

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

@@ -168,10 +168,11 @@ export async function runInstallCommand({ options, runtime, action = "install" }
   // An uninstall is planned from what ACC recorded writing, not only from what
   // is on the machine now. A client can be removed after ACC installed into it,
   // and its configuration directory - with ACC's files in it - stays behind.
-  const recorded = action === "uninstall"
-    ? (await loadOwnership({ dataHome })).installs
-    : [];
-  const plan = planInstallation({ adapters, detected, context, action, recorded });
+  // Read on both actions now. An uninstall plans from it because a client can
+  // leave the machine after ACC wrote to it; an install reads it to see which
+  // ACC is already wired, so an older copy cannot replace a newer one in
+  // silence.
+  const recorded = (await loadOwnership({ dataHome })).installs;
 
   const dryRun = options.dryRun === true;
   // Recorded with the install, so a later run can tell that the bundle sitting
@@ -180,6 +181,14 @@ export async function runInstallCommand({ options, runtime, action = "install" }
   const accVersion = typeof runtime.version === "function"
     ? await runtime.version().catch(() => null)
     : null;
+  // Naming a client is an answer to the question the version probe was guessing
+  // at. `acc install --adapter gemini_cli` says the client is here, whatever
+  // PATH this process happens to carry.
+  const requested = options.adapter === undefined
+    ? []
+    : (Array.isArray(options.adapter) ? options.adapter : [options.adapter]);
+  const plan = planInstallation({ adapters, detected, context, action, recorded,
+    accVersion, allowDowngrade: options.downgrade === true, requested });
   const result = await applyPlan({ plan, adapters, context, dataHome, dryRun, accVersion });
 
   const acted = actedOn(result);

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/core",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "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.8",
+  "version": "0.1.10",
   "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.8",
+  "version": "0.1.10",
   "private": true,
   "type": "module",
   "exports": { ".": "./src/index.mjs" },

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

@@ -8,7 +8,7 @@ import { AccError, EXIT } from "@agents-can-communicate/protocol";
  * it previews is a decoration, and the operator would find out only afterwards.
  */
 export function planInstallation({ adapters, detected, context, action = "install",
-  recorded = [] }) {
+  recorded = [], accVersion = null, allowDowngrade = false, requested = [] }) {
   if (!["install", "uninstall"].includes(action)) {
     throw new AccError(EXIT.USAGE, `unknown installation action: ${action}`, { action });
   }
@@ -17,6 +17,15 @@ export function planInstallation({ adapters, detected, context, action = "instal
   // authority rather than detection: the record is the only account of what was
   // written, and a client's configuration directory outlives the client.
   const recordedById = new Map(recorded.map(install => [install.adapterId, install]));
+  // Presence is decided by running the client's `--version`, which answers "can
+  // ACC run this client" - not the question that matters, since ACC never runs
+  // it: the client runs ACC's hook. A client installed under a different Node
+  // version sat there with its own configuration directory while every install
+  // reported it missing. Its existence cannot be inferred from that directory,
+  // because ACC creates one itself - an earlier attempt at this read a client's
+  // own test fixture as proof the client was there. A person naming the client
+  // can be.
+  const askedFor = new Set(requested ?? []);
   const operations = [];
   const skipped = [];
 
@@ -38,11 +47,30 @@ export function planInstallation({ adapters, detected, context, action = "instal
       ? recordedById.get(entry.adapterId)
       : undefined;
 
-    if (!entry.present && record === undefined) {
+    if (!entry.present && record === undefined && !askedFor.has(entry.adapterId)) {
       // Named rather than dropped: "nothing happened" and "that client is not
-      // installed on this machine" look the same in an empty list.
+      // installed on this machine" look the same in an empty list. And the
+      // message names the way past itself, because the verdict is on PATH
+      // rather than on the machine.
       skipped.push({ adapterId: entry.adapterId,
-        reason: `${entry.displayName ?? entry.adapterId} is not installed on this machine` });
+        reason: `${entry.displayName ?? entry.adapterId} is not installed on this machine; `
+          + `if it is, wire it with --adapter ${entry.adapterId}` });
+      continue;
+    }
+    // The version doing the installing is whichever `acc` came first on PATH,
+    // and the shim it writes pins that copy's node and runner. So a second ACC
+    // on the machine quietly replaces every client's wiring with its own, older
+    // code, and the only symptom is a guard behaving like the version it came
+    // from. `recordInstall` has always written `accVersion` for exactly this
+    // comparison; nothing read it in this direction until now.
+    //
+    // Never on an uninstall: the older ACC is often the only thing that knows
+    // what it wrote, and refusing it would strand the wiring this undoes.
+    const wired = recordedById.get(entry.adapterId)?.accVersion;
+    if (action === "install" && !allowDowngrade && isOlder(accVersion, wired)) {
+      skipped.push({ adapterId: entry.adapterId,
+        reason: `${wired} is already wired here and this is ${accVersion}; `
+          + "run the newer acc, or pass --downgrade to wire this one deliberately" });
       continue;
     }
     if (record === undefined && typeof adapter.planInstall !== "function") {
@@ -83,3 +111,29 @@ export function planInstallation({ adapters, detected, context, action = "instal
   }
   return { schemaVersion: 1, action, operations, skipped };
 }
+
+/**
+ * Is `candidate` an earlier release than `installed`?
+ *
+ * Numeric per segment, because the first comparison that matters in practice is
+ * 0.1.9 against 0.1.10, where a string comparison reverses the answer and starts
+ * refusing every legitimate install. Anything unreadable answers false: a
+ * corrupt record must not make the machine unrepairable by the command that
+ * exists to repair it.
+ */
+function isOlder(candidate, installed) {
+  const parse = value => {
+    if (typeof value !== "string") return null;
+    const parts = value.trim().split(".");
+    if (parts.length !== 3) return null;
+    const numbers = parts.map(part => (/^\d+$/.test(part) ? Number(part) : null));
+    return numbers.includes(null) ? null : numbers;
+  };
+  const left = parse(candidate);
+  const right = parse(installed);
+  if (left === null || right === null) return false;
+  for (let index = 0; index < 3; index += 1) {
+    if (left[index] !== right[index]) return left[index] < right[index];
+  }
+  return false;
+}

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

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

package/package.json

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