agents-can-communicate 0.1.0 → 0.1.2

package/README.md

@@ -75,13 +75,42 @@ npm install -g agents-can-communicate
 
 Then wire up the clients you have:
 
+```bash
+acc install
+```
+
+It names every file it wrote, in your own home-relative paths, and how to undo it. Open your
+clients in the project afterwards — in one directory or in several worktrees — and work
+normally.
+
+If you would rather look before it writes, `acc install --dry-run` prints the same list and
+changes nothing. `acc uninstall` takes it all back out.
+
 <!-- test:command -->
 ```bash
 acc install --dry-run
 ```
 
-This prints every file it would touch. Run `acc install` to apply it, then open your clients
-in the project — in one directory or in several worktrees — and work normally.
+## Keeping it current
+
+```bash
+acc update            # asks npm; --apply installs it and re-wires the clients
+```
+
+An upgrade is two steps, because it lands in two places. `npm install -g` replaces the CLI
+and the hook runtime — a client runs the runtime out of the npm directory rather than a copy
+— and leaves the bundle written into that client alone, including the skills the agents
+read. `acc install` refreshes it, and `acc doctor` says so when the two disagree:
+
+```console
+$ acc doctor
+store healthy; 2 live session(s); protection guarded; 3 of 4 adapter(s) installed
+  acc install --adapter claude_code  # plugin is 0.1.1, acc is 0.2.0
+```
+
+`acc update` is the only command that reaches the network. `acc doctor` reads what it
+remembered and asks at most once a day; nothing on the hook path ever asks, since a hook
+runs on every turn inside a five-second budget. `ACC_NO_UPDATE_CHECK=1` turns both off.
 
 ## Commands
 

package/bin/acc.mjs

@@ -3,7 +3,7 @@ import { randomBytes } from "node:crypto";
 import { readFile } from "node:fs/promises";
 
 import { createId } from "@agents-can-communicate/protocol";
-import { main } from "@agents-can-communicate/cli";
+import { askConfirmation, main } from "@agents-can-communicate/cli";
 
 // The composition root is the only place allowed to reach for ambient time and
 // randomness; everything below it receives them as ports.
@@ -15,6 +15,13 @@ const runtime = {
   stderr: process.stderr,
   clock: { now: () => new Date().toISOString() },
   ids: { next: kind => createId(kind, randomBytes) },
+  // Asked only by `acc config init`, and only when stdout is a terminal. There
+  // was no port here at all, so the question went to the fallback that always
+  // answers no: in a real terminal the command printed "not written" and never
+  // said why, and `--yes` - the flag documented for runs with nobody to ask -
+  // was the only way to write the file.
+  confirm: question => askConfirmation(question,
+    { input: process.stdin, output: process.stdout }),
   // Asked for only by `acc version`, so a package missing its own manifest
   // fails that one command rather than every command.
   version: async () => JSON.parse(

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

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

@@ -1,5 +1,5 @@
 {
   "name": "agents-can-communicate",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "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-codex/package.json

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

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

@@ -1,6 +1,6 @@
 {
   "name": "agents-can-communicate",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Coordinate this Codex session with other AI agent sessions working in the same workspace.",
   "license": "UNLICENSED",
   "keywords": ["coordination", "multi-agent", "claims", "handoff"],

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

@@ -1,6 +1,6 @@
 {
   "name": "agents-can-communicate",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "description": "Coordinate this Gemini CLI session with other AI agent sessions working in the same workspace.",
   "contextFileName": "skills/acc/SKILL.md"
 }

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

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

@@ -1,6 +1,6 @@
 {
   "name": "agents-can-communicate",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "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-sdk/package.json

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

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

@@ -1,5 +1,7 @@
 import path from "node:path";
 
+import { editJson } from "./json-text.mjs";
+
 const MARKER = "acc:owned";
 // Ownership of single entries inside a container someone else also writes to.
 // `enabledPlugins` in a Claude Code settings file holds every plugin the user
@@ -150,10 +152,23 @@ export function jsonStyleOf(text) {
  * Unchanged content is not rewritten at all, so a second install touches
  * nothing. A file that does not exist yet is ACC's to create, and gets the
  * conventional trailing newline.
+ *
+ * What is there is edited rather than re-emitted. Reading the style back out of
+ * the file kept the indentation, and still reformatted everything the style
+ * could not describe: a nested object a person had written on one line came
+ * back as three, and a blank line between sections was gone. The bytes are
+ * theirs, and the diff ACC leaves should be of what it changed.
  */
 export async function writeForeignJson(file, value, { readFile, writeFile, mkdir }) {
   const current = await readFile(file, "utf8").catch(() => null);
-  const text = formatJsonAs(value, jsonStyleOf(current));
+  const style = jsonStyleOf(current);
+  // Null when the original cannot be read, or when the edit came back meaning
+  // something other than it was asked to write. Then this is the whole-file
+  // re-emit it has always been.
+  const spliced = typeof current === "string" ? editJson(current, value, style.indent) : null;
+  const text = spliced === null
+    ? formatJsonAs(value, style)
+    : (style.trailingNewline === false ? spliced : `${spliced}\n`);
   if (current === text) return false;
   await mkdir(path.dirname(file), { recursive: true });
   await writeFile(file, text);

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

@@ -87,7 +87,34 @@ export async function writeHookShim({ dir, adapterId, runner = defaultRunner(),
     "# Generated by ACC at install time. The paths are pinned deliberately:",
     "# a hook runs with an environment that may carry neither PATH nor a shell",
     "# profile, and a command that cannot be found fails silently on every event.",
-    `exec ${quote(node)} ${quote(runner)} ${adapterId} "$@"`,
+    "#",
+    "# Pinned first, and then asked for, because the pinned pair moves. A node",
+    "# version manager changes both the interpreter and the directory global",
+    "# packages live in, and a shim naming the old ones failed on every event",
+    "# with nothing to read but exit 126 - no presence, no claims, no messages,",
+    "# and nothing anywhere saying why.",
+    `ACC_NODE=${quote(node)}`,
+    `ACC_RUNNER=${quote(runner)}`,
+    'if [ -x "$ACC_NODE" ] && [ -f "$ACC_RUNNER" ]; then',
+    `  exec "$ACC_NODE" "$ACC_RUNNER" ${adapterId} "$@"`,
+    "fi",
+    "# Whatever node is current, if this package is installed under it: `acc-hook`",
+    "# is the binary npm links, so a reinstall is found without knowing where.",
+    "# It needs node too - its shebang is `env node` - and `exec` that fails ends",
+    "# this script where it stands, taking the fallbacks below with it: measured",
+    "# as exit 127 and `env: node: No such file or directory`, in place of the",
+    "# line that says what to do.",
+    "if command -v acc-hook >/dev/null 2>&1 && command -v node >/dev/null 2>&1; then",
+    `  exec acc-hook ${adapterId} "$@"`,
+    "fi",
+    'if [ -f "$ACC_RUNNER" ] && command -v node >/dev/null 2>&1; then',
+    `  exec node "$ACC_RUNNER" ${adapterId} "$@"`,
+    "fi",
+    "# Say so, and let the turn continue. Hooks fail open by design, and a broken",
+    "# install must not be the reason somebody's session stops working.",
+    'echo "acc: the hook runner installed here is gone (node: $ACC_NODE)." >&2',
+    'echo "acc: run \'acc install\' to wire this client to the acc you have now." >&2',
+    "exit 0",
     "",
   ].join("\n"));
   await chmod(target, 0o755);

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

@@ -8,6 +8,7 @@ export { assertRunner, bakeSkillCommand, defaultCli, defaultRunner, removeInstal
 export { BEGIN, END, removeTomlBlock, renderBlock, stripBlock, tomlString, writeTomlBlock }
   from "./toml-block.mjs";
 export { projectContext } from "./context-projector.mjs";
+export { editJson, readJson } from "./json-text.mjs";
 export { formatJsonAs, jsonStyleOf, mergeOwnedConfig, mergeOwnedEntries, ownedEntries, ownedKeys,
   acccreatedFile, removeIfEmpty, removeOwnedConfig, removeOwnedEntries, writeForeignJson,
   blankJson, blankText } from "./config-merge.mjs";

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

@@ -0,0 +1,195 @@
+/**
+ * Edit a JSON document as text, so what was not changed is not rewritten.
+ *
+ * `JSON.parse` then `JSON.stringify` re-emits every byte of a file, which
+ * reformats the parts ACC was not asked to touch: a nested object a person kept
+ * on one line comes back as three, and a blank line between sections is gone.
+ * The bytes are the user's, and a tool that edits their settings should leave a
+ * diff of what it changed rather than of how it prints.
+ *
+ * So the original text is kept and spliced. Anything whose value is unchanged is
+ * copied across verbatim - not re-serialised and hoped to match - and only a
+ * member that was added, removed or replaced is written fresh.
+ *
+ * The result is parsed back and compared to the value it was asked to write. A
+ * splice that would change meaning is discarded rather than written, and the
+ * caller falls back to plain `JSON.stringify`: the worst this can do is what
+ * was already being done.
+ */
+
+const WHITESPACE = " \t\n\r";
+const same = (left, right) => JSON.stringify(left) === JSON.stringify(right);
+
+const isObject = value =>
+  value !== null && typeof value === "object" && !Array.isArray(value);
+
+/**
+ * Read a JSON document into a tree that remembers where everything was.
+ *
+ * @returns the root node, or null for anything this cannot read - which the
+ * caller treats the same way as a file it must not touch.
+ */
+export function readJson(text) {
+  if (typeof text !== "string") return null;
+  let at = 0;
+
+  const skip = () => { while (at < text.length && WHITESPACE.includes(text[at])) at += 1; };
+  const fail = () => { throw new SyntaxError(`unreadable JSON at ${at}`); };
+  const expect = character => { if (text[at] !== character) fail(); at += 1; };
+
+  const readString = () => {
+    expect('"');
+    while (at < text.length) {
+      if (text[at] === "\\") { at += 2; continue; }
+      if (text[at] === '"') { at += 1; return; }
+      at += 1;
+    }
+    fail();
+  };
+
+  const readValue = () => {
+    skip();
+    const start = at;
+    if (text[at] === "{") return readObject(start);
+    if (text[at] === "[") return readArray(start);
+    if (text[at] === '"') { readString(); }
+    else {
+      // Numbers, true, false, null: read to the next structural character and
+      // let `JSON.parse` below be the judge of what was read.
+      while (at < text.length && !",}]".includes(text[at]) && !WHITESPACE.includes(text[at])) {
+        at += 1;
+      }
+      if (at === start) fail();
+    }
+    const slice = text.slice(start, at);
+    return { kind: "scalar", start, end: at, value: JSON.parse(slice) };
+  };
+
+  function readObject(start) {
+    expect("{");
+    const members = [];
+    const value = {};
+    for (;;) {
+      // Everything between the previous member and this one - the comma, the
+      // newline, the indentation - is kept as it was written.
+      const gapStart = at;
+      skip();
+      if (text[at] === "}") { at += 1; break; }
+      if (members.length > 0) { expect(","); skip(); }
+      if (text[at] === "}") { at += 1; break; }
+      const keyStart = at;
+      readString();
+      const key = JSON.parse(text.slice(keyStart, at));
+      skip();
+      expect(":");
+      const node = readValue();
+      members.push({ key, gapStart, keyStart, valueStart: node.start, end: node.end, node });
+      // Defined rather than assigned: `value.__proto__ = …` sets the prototype
+      // of an ordinary object instead of adding a key to it, so a config with
+      // that key read back without it - and the comparison that decides whether
+      // a subtree changed would be answering about a different document than
+      // the one on disk. This is what `JSON.parse` does with the same input.
+      Object.defineProperty(value, key,
+        { value: node.value, writable: true, enumerable: true, configurable: true });
+    }
+    return { kind: "object", start, end: at, value, members };
+  }
+
+  function readArray(start) {
+    expect("[");
+    const items = [];
+    const value = [];
+    for (;;) {
+      skip();
+      if (text[at] === "]") { at += 1; break; }
+      if (items.length > 0) { expect(","); skip(); }
+      if (text[at] === "]") { at += 1; break; }
+      const node = readValue();
+      items.push(node);
+      value.push(node.value);
+    }
+    return { kind: "array", start, end: at, value, items };
+  }
+
+  try {
+    const root = readValue();
+    skip();
+    // Trailing content means this is not the document it appears to be.
+    return at === text.length ? root : null;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Write `value` into `text`, changing only what differs.
+ *
+ * @returns the edited document, or null when it cannot be done safely - an
+ * unreadable original, or a splice that came back meaning something else.
+ */
+export function editJson(text, value, indent) {
+  const root = readJson(text);
+  if (root === null) return null;
+
+  const unit = typeof indent === "number" ? " ".repeat(indent) : (indent ?? "  ");
+  const pad = depth => unit.repeat(depth);
+  const broken = unit !== "";
+
+  // A value with no original to preserve: printed the way this file prints,
+  // then moved to the depth it sits at.
+  const fresh = (subject, depth) => {
+    const printed = JSON.stringify(subject, null, unit);
+    return broken ? printed.split("\n").join(`\n${pad(depth)}`) : printed;
+  };
+
+  const render = (node, subject, depth) => {
+    if (node !== null && same(node.value, subject)) return text.slice(node.start, node.end);
+    if (node?.kind === "object" && isObject(subject)) return spliceObject(node, subject, depth);
+    return fresh(subject, depth);
+  };
+
+  function spliceObject(node, subject, depth) {
+    const byKey = new Map(node.members.map(member => [member.key, member]));
+    const pieces = [];
+
+    for (const key of Object.keys(subject)) {
+      const member = byKey.get(key);
+      if (member === undefined) {
+        // New: written in this file's own shape rather than copied from nowhere.
+        pieces.push(broken
+          ? `\n${pad(depth + 1)}${JSON.stringify(key)}: ${fresh(subject[key], depth + 1)}`
+          : `${JSON.stringify(key)}:${fresh(subject[key], depth + 1)}`);
+        continue;
+      }
+      // The separator that preceded it, the key as it was spelled, and the
+      // colon and spacing after it: all of it is the user's, and none of it is
+      // what changed.
+      const separator = text.slice(member.gapStart, member.keyStart);
+      const label = text.slice(member.keyStart, member.valueStart);
+      pieces.push(separator.replace(",", "") + label + render(member.node, subject[key], depth + 1));
+    }
+
+    // The comma belongs between members, so it is placed rather than copied:
+    // a member that used to be first no longer is, and one that is now first
+    // must not arrive with the comma it used to carry.
+    const body = pieces.join(",");
+    // What sat between the last member and the brace, when the last member is
+    // still the one that was there; otherwise this file's own closing shape.
+    const last = node.members.at(-1);
+    const closing = last !== undefined && Object.keys(subject).at(-1) === last.key
+      ? text.slice(last.end, node.end - 1)
+      : (broken ? `\n${pad(depth)}` : "");
+    if (pieces.length === 0) return "{}";
+    return `{${body}${closing}}`;
+  }
+
+  const edited = render(root, value, 0);
+  // The safety net. A splice that parses to something else is not written.
+  let read;
+  try {
+    read = JSON.parse(edited);
+  } catch {
+    return null;
+  }
+  return same(read, value) ? edited : null;
+}

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

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

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

@@ -56,8 +56,17 @@ export const COMMANDS = Object.freeze({
   // inside a handler that has already decided what to do.
   config: { required: [], optional: [], flags: ["yes", "force"],
     subcommands: ["init", "validate"] },
-  install: { required: [], optional: ["adapter", "home"], flags: ["dry-run", "yes"] },
-  uninstall: { required: [], optional: ["adapter", "home"], flags: ["yes"] },
+  // 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"] },
+  // `--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.
+  uninstall: { required: [], optional: ["adapter", "home"], flags: ["dry-run"] },
+  // Asking npm whether there is a newer ACC. The one command that touches the
+  // network, and never on the hook path.
+  update: { required: [], optional: [], flags: ["apply"] },
   // The two things a person types first after installing from a registry. The
   // CLI answered neither: `acc --version` and `acc --help` were both "unknown
   // command", and `acc` on its own asked for a command without naming one.

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

@@ -0,0 +1,33 @@
+import { once } from "node:events";
+import { createInterface } from "node:readline/promises";
+
+/**
+ * Ask a yes-or-no question and wait for the answer.
+ *
+ * A port rather than a call to the terminal, so the composition root hands it
+ * in and a test hands in two streams instead. There was no port at all:
+ * `runtime.confirm` fell back to a function that always answered no, so `acc
+ * config init` in a real terminal printed `not written` and never said why -
+ * and `--yes`, documented for runs with nobody to ask, was the only way to
+ * write the file.
+ *
+ * Anything that is not yes is no. A confirmation that reads a stray newline as
+ * agreement is not a confirmation.
+ */
+export async function askConfirmation(question, { input, output }) {
+  const dialogue = createInterface({ input, output });
+  try {
+    const asked = dialogue.question(`${question}\n[y/N] `);
+    // The input closing before an answer arrives is the reader leaving - Ctrl+D,
+    // or a pipe that ended - which is a refusal rather than a failure. Raced
+    // rather than caught: the question simply never settles on a stream that
+    // ends, so waiting for it alone hangs.
+    asked.catch(() => {});
+    const answer = await Promise.race([asked, once(dialogue, "close").then(() => "")]);
+    return /^y(es)?$/i.test(answer.trim());
+  } catch {
+    return false;
+  } finally {
+    dialogue.close();
+  }
+}

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

@@ -1,10 +1,13 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 
-import { detectInstallation, verifyOwned } from "@agents-can-communicate/installer";
+import { detectInstallation, loadOwnership, verifyOwned }
+  from "@agents-can-communicate/installer";
 import { AccError, EXIT } from "@agents-can-communicate/protocol";
 
-import { ALL_ADAPTERS, clientContext } from "./install-command.mjs";
+import { ALL_ADAPTERS, clientContext, probeTimeout } from "./install-command.mjs";
 import { platformPaths } from "./platform-paths.mjs";
+import { noticeUpdate } from "./update-check.mjs";
 import { diagnoseFilesystemStore, repairFilesystemStore }
   from "@agents-can-communicate/storage-filesystem";
 
@@ -13,6 +16,23 @@ import { diagnoseFilesystemStore, repairFilesystemStore }
  * closed: anything blocked or corrupt stops the run rather than being repaired
  * on top of state the tool cannot even read.
  */
+/**
+ * The bundle in a client outlives the package that put it there.
+ *
+ * `npm install -g` replaces this CLI and the hook runtime - the shim runs the
+ * runtime out of the npm directory rather than a copy - and does not touch what
+ * was written into the client: its `hooks.json`, and the skills the agents read.
+ * Measured: after an upgrade the client still had `0.1.0` while `acc --version`
+ * said `0.1.1`, and doctor called it healthy.
+ *
+ * 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.
+ */
+export function staleInstall({ recorded, running }) {
+  if (typeof recorded !== "string" || typeof running !== "string") return null;
+  return recorded === running ? null : { recorded, running };
+}
+
 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.
@@ -21,7 +41,12 @@ async function diagnoseAdapters({ options, runtime }) {
   const { data: dataHome } = platformPaths({ platform: runtime?.platform,
     env: runtime?.env ?? {} });
   const adapters = ALL_ADAPTERS();
-  const detected = await detectInstallation({ adapters, context: clients });
+  const detected = await detectInstallation({ adapters, context: clients,
+    probeTimeoutMs: probeTimeout(runtime?.env) });
+  const record = await loadOwnership({ dataHome });
+  const running = typeof runtime?.version === "function"
+    ? await runtime.version().catch(() => null)
+    : null;
 
   return Promise.all(detected.map(async entry => {
     // Compared against what ACC recorded writing, so a plugin someone has since
@@ -37,7 +62,15 @@ async function diagnoseAdapters({ options, runtime }) {
     if (owned.missing.length > 0) {
       remediation.push(`acc install --adapter ${entry.adapterId}  # files are missing`);
     }
-    return { ...entry, owned: { modified: owned.modified, missing: owned.missing,
+    const stale = staleInstall({
+      recorded: record.installs.find(install => install.adapterId === entry.adapterId)
+        ?.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 };
   }));
 }
@@ -48,6 +81,14 @@ export async function runDoctor({ options, context, runtime }) {
     ? await repairFilesystemStore({ root, clock: context.service.clock })
     : await diagnoseFilesystemStore({ root });
   const adapters = await diagnoseAdapters({ options, runtime });
+  const { data: dataHome } = platformPaths({ platform: runtime?.platform,
+    env: runtime?.env ?? {} });
+  const running = typeof runtime?.version === "function"
+    ? 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,
+    io: { readFile, writeFile, mkdir } });
 
   // Before the store is read for anything else. `collectStatus` reads every
   // record, so on the store this command exists to describe it threw first and
@@ -76,10 +117,20 @@ export async function runDoctor({ options, context, runtime }) {
     store: report,
     // Capabilities are reported from what is actually installed, never assumed.
     adapters,
-    remediation: adapters.flatMap(adapter => adapter.remediation),
+    update,
+    remediation: [...adapters.flatMap(adapter => adapter.remediation),
+      // Said here rather than in its own line of prose, because this list is
+      // what a reader acts on and an upgrade is one more thing to run.
+      ...(update.newer ? [`acc update --apply  # ${update.latest} is on npm, `
+        + `you have ${running}`] : [])],
   };
   const installed = adapters.filter(adapter => adapter.installed).length;
-  const text = `store healthy; ${status.counts.live} live session(s); `
-    + `protection ${status.protection}; ${installed} of ${adapters.length} adapter(s) installed`;
+  // The remediation was computed, put in the data, and never printed: the
+  // command documented as saying "what to run next" said it only to `--json`.
+  // A person running `acc doctor` on a client wired to an older plugin was told
+  // the store was healthy and nothing else.
+  const text = [`store healthy; ${status.counts.live} live session(s); `
+    + `protection ${status.protection}; ${installed} of ${adapters.length} adapter(s) installed`,
+  ...data.remediation.map(line => `  ${line}`)].join("\n");
   return { data, text };
 }

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

@@ -16,7 +16,7 @@ const GROUPS = Object.freeze([
   ["In a session", ["status", "sync", "work", "claim", "release", "ack", "message",
     "request", "task", "workstream", "decide", "finish"]],
   ["Driven by adapters, not by people", ["attach", "heartbeat", "detach"]],
-  ["About acc", ["help", "version"]],
+  ["About acc", ["help", "version", "update"]],
 ]);
 
 const SUMMARY = Object.freeze({
@@ -41,6 +41,7 @@ const SUMMARY = Object.freeze({
   detach: "close a session",
   help: "this list",
   version: "print the version that is installed",
+  update: "ask npm whether a newer acc exists; --apply installs it",
 });
 
 /** The same list `acc help --json` returns, so a tool can read it too. */

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

@@ -1,6 +1,7 @@
 // Composition root: discovery, runtime locations, and the CLI surface.
 export { main } from "./main.mjs";
 export { COMMANDS, parseArgs } from "./args.mjs";
+export { askConfirmation } from "./confirm.mjs";
 // Exported so a test can hold every adapter to where it plans to write and
 // which binary decides it runs at all.
 export { ALL_ADAPTERS, clientContext } from "./install-command.mjs";

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

@@ -5,7 +5,7 @@ import { createClaudeCodeAdapter } from "@agents-can-communicate/adapter-claude-
 import { createCodexAdapter } from "@agents-can-communicate/adapter-codex";
 import { createGeminiCliAdapter } from "@agents-can-communicate/adapter-gemini-cli";
 import { createKimiAdapter } from "@agents-can-communicate/adapter-kimi";
-import { applyPlan, detectInstallation, planInstallation }
+import { applyPlan, detectInstallation, loadOwnership, planInstallation }
   from "@agents-can-communicate/installer";
 import { AccError, EXIT } from "@agents-can-communicate/protocol";
 
@@ -28,6 +28,20 @@ export const clientContext = home => ({
 export const ALL_ADAPTERS = () => [createClaudeCodeAdapter(), createCodexAdapter(),
   createGeminiCliAdapter(), createKimiAdapter()];
 
+/**
+ * How long to wait for a client to say its version.
+ *
+ * Detection spawns the client's own binary, and three seconds is generous on an
+ * idle machine and not always enough on a busy one: a cold start that overruns
+ * it makes an installed client look absent, and the installer skips it saying so
+ * in as many words. Raising it is for the machine that needs it - a loaded CI
+ * runner, a slow disk - rather than a default nobody can change.
+ */
+export function probeTimeout(env) {
+  const asked = Number.parseInt(env?.ACC_PROBE_TIMEOUT_MS ?? "", 10);
+  return Number.isFinite(asked) && asked > 0 ? asked : undefined;
+}
+
 function selectAdapters(requested) {
   const all = ALL_ADAPTERS();
   if (requested === undefined) return all;
@@ -60,11 +74,52 @@ function selectAdapters(requested) {
  * carries one per skipped adapter and the result one per failure - and only
  * `--json` ever showed them.
  */
-export function describeOutcome({ action, acted, failed = [], skipped = [] }) {
+const shorten = (file, home) =>
+  typeof home === "string" && home !== "" && file.startsWith(`${home}/`)
+    ? `~${file.slice(home.length)}`
+    : file;
+
+/**
+ * What one adapter did, path by path.
+ *
+ * `installed 3 adapter(s)` was the whole account of a command that had just
+ * written into three other tools' configuration inside someone's home. The list
+ * existed all along - it is what `--dry-run` prints - and the run that actually
+ * did the work printed a number.
+ *
+ * An install says what it wrote from the plan it carried out, in the same words
+ * the preview uses. An uninstall says what was removed and what was held back,
+ * because those are decided while it runs: bytes that stopped matching what ACC
+ * wrote are someone's now, and are kept.
+ */
+export function describeChanges(operation, home) {
+  const artifacts = operation.artifacts ?? [];
+  const edited = artifacts.filter(artifact => artifact.kind === "merge")
+    .map(artifact => `  edited  ${shorten(artifact.path, home)}`);
+  if (operation.action !== "uninstall") {
+    return [...artifacts.filter(artifact => artifact.kind !== "merge")
+      .map(artifact => `  created ${shorten(artifact.path, home)}`), ...edited];
+  }
+  return [
+    ...(operation.removed ?? []).map(file => `  removed ${shorten(file, home)}`),
+    ...edited,
+    ...(operation.kept ?? [])
+      .map(file => `  kept    ${shorten(file, home)} - changed since ACC wrote it`),
+  ];
+}
+
+export function describeOutcome({ action, acted, failed = [], skipped = [],
+  operations = [], home }) {
   return [`${action}ed ${acted} adapter(s)`
     + (failed.length > 0 ? `; ${failed.length} failed` : ""),
+  ...operations.filter(operation => operation.applied)
+    .flatMap(operation => describeChanges(operation, home)),
   ...skipped.map(entry => `  skip ${entry.adapterId}: ${entry.reason}`),
-  ...failed.map(entry => `  ${entry.adapterId}: ${entry.error}`)].join("\n");
+  ...failed.map(entry => `  ${entry.adapterId}: ${entry.error}`),
+  // 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"] : []),
+  ].join("\n");
 }
 
 /**
@@ -80,6 +135,21 @@ export function failureOf({ action, acted, failed = [] }) {
     describeOutcome({ action, acted, failed }), { failed });
 }
 
+/**
+ * How many adapters this actually did something to.
+ *
+ * `applied` means the adapter's own step ran, which on an uninstall is true of
+ * every client on the machine whether ACC had ever written to it or not. So
+ * `uninstalled 3 adapter(s)` was the report on a machine where ACC had installed
+ * nothing at all - printed by the same run that skipped the one client it had
+ * actually written to.
+ */
+export function actedOn(result) {
+  return result.operations.filter(operation => operation.applied
+    && (result.action === "install"
+      || (operation.removed?.length ?? 0) + (operation.changes?.length ?? 0) > 0)).length;
+}
+
 export async function runInstallCommand({ options, runtime, action = "install" }) {
   const adapters = selectAdapters(options.adapter);
   const home = options.home ?? runtime.env?.HOME ?? homedir();
@@ -87,13 +157,26 @@ export async function runInstallCommand({ options, runtime, action = "install" }
   const { data: dataHome } = platformPaths({ platform: runtime.platform,
     env: runtime.env ?? {} });
 
-  const detected = await detectInstallation({ adapters, context });
-  const plan = planInstallation({ adapters, detected, context, action });
+  const detected = await detectInstallation({ adapters, context,
+    probeTimeoutMs: probeTimeout(runtime.env) });
+  // 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 });
 
   const dryRun = options.dryRun === true;
-  const result = await applyPlan({ plan, adapters, context, dataHome, dryRun });
+  // Recorded with the install, so a later run can tell that the bundle sitting
+  // in a client is older than the code now running. Updating the npm package
+  // replaces this CLI and the hook runtime and leaves that bundle untouched.
+  const accVersion = typeof runtime.version === "function"
+    ? await runtime.version().catch(() => null)
+    : null;
+  const result = await applyPlan({ plan, adapters, context, dataHome, dryRun, accVersion });
 
-  const acted = result.operations.filter(operation => operation.applied).length;
+  const acted = actedOn(result);
   if (dryRun) {
     return { data: { ...result, plan, dataHome },
       text: [`would ${action}:`, ...plan.operations.flatMap(operation => operation.summary),
@@ -102,6 +185,6 @@ export async function runInstallCommand({ options, runtime, action = "install" }
 
   return { data: { ...result, plan, dataHome },
     text: describeOutcome({ action, acted, failed: result.failed,
-      skipped: plan.skipped }),
+      skipped: plan.skipped, operations: result.operations, home }),
     error: failureOf({ action, acted, failed: result.failed }) };
 }

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

@@ -9,6 +9,7 @@ import { parseArgs, positiveNumber } from "./args.mjs";
 // with the argument already half-applied.
 const usage = message => new AccError(EXIT.USAGE, message);
 import { describeCommands, helpText } from "./help.mjs";
+import { runUpdateCommand } from "./update-command.mjs";
 import { runConfigCommand } from "./config-command.mjs";
 import { runInstallCommand } from "./install-command.mjs";
 import { runDoctor } from "./doctor-command.mjs";
@@ -252,7 +253,12 @@ const HANDLERS = Object.freeze({
       // command demands --yes rather than hanging or assuming consent.
       interactive: runtime.stdout?.isTTY === true,
       yes: options.yes === true,
-      confirm: runtime.confirm ?? (async () => false),
+      // Not a silent no. A build that cannot ask says so: falling back to
+      // "declined" is how `acc config init` came to print `not written` in a
+      // terminal where nobody had been asked anything.
+      confirm: runtime.confirm ?? (async () => {
+        throw new AccError(EXIT.DATA, "this build was assembled without a way to ask");
+      }),
       force: options.force === true,
       // Opened lazily and only by `init`: `config validate` has to work on a
       // workspace discovery cannot open, which is what a reader runs it to
@@ -275,6 +281,8 @@ const HANDLERS = Object.freeze({
 
   doctor: async ({ options, context, runtime }) => runDoctor({ options, context, runtime }),
 
+  update: async ({ options, runtime }) => runUpdateCommand({ options, runtime }),
+
   help: async () => ({ data: { commands: describeCommands() }, text: helpText() }),
 
   version: async ({ runtime }) => {
@@ -294,7 +302,8 @@ const HANDLERS = Object.freeze({
 /**
  * @returns {Promise<number>} the process exit code
  */
-const NO_WORKSPACE = Object.freeze(["config", "install", "uninstall", "help", "version"]);
+const NO_WORKSPACE = Object.freeze(["config", "install", "uninstall", "help", "version",
+  "update"]);
 
 export async function main(argv, runtime) {
   const write = (stream, text) => new Promise((resolve, reject) =>

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

@@ -0,0 +1,113 @@
+import path from "node:path";
+
+import { AccError, EXIT } from "@agents-can-communicate/protocol";
+
+/**
+ * Asking npm whether there is a newer ACC.
+ *
+ * This is the only part of ACC that touches the network, and it is kept to one
+ * file for that reason. It is never on the hook path: a hook runs every turn
+ * inside a five-second budget and fails open, so a stalled socket there would
+ * cost every turn on the machine something and report nothing. `acc update`
+ * asks, `acc doctor` reads what was cached, and the answer is remembered for a
+ * day so a diagnostic run does not become traffic.
+ *
+ * `ACC_NO_UPDATE_CHECK=1` turns it off entirely, and then it says it is off
+ * rather than saying the version is current.
+ */
+const REGISTRY = "https://registry.npmjs.org/agents-can-communicate/latest";
+const EVERY_MS = 24 * 60 * 60 * 1000;
+const TIMEOUT_MS = 3_000;
+
+const cacheFile = dataHome => path.join(dataHome, "acc", "update-check.json");
+
+export const checkingIsOff = env => {
+  const value = env?.ACC_NO_UPDATE_CHECK;
+  return value !== undefined && value !== "" && value !== "0";
+};
+
+const numbers = version => (typeof version === "string"
+  ? version.trim().split("-", 1)[0].split(".") : [])
+  .map(part => Number.parseInt(part, 10));
+
+/**
+ * Whether `candidate` is a later release than `current`.
+ *
+ * Anything unreadable is not newer. Telling somebody to upgrade because a
+ * version could not be parsed is worse than saying nothing.
+ */
+export function isNewer(candidate, current) {
+  const left = numbers(candidate);
+  const right = numbers(current);
+  if (left.length === 0 || left.some(Number.isNaN)) return false;
+  if (right.length === 0 || right.some(Number.isNaN)) return false;
+  for (let index = 0; index < Math.max(left.length, right.length); index += 1) {
+    const one = left[index] ?? 0;
+    const other = right[index] ?? 0;
+    if (one !== other) return one > other;
+  }
+  return false;
+}
+
+/** Whether a remembered answer is old enough to ask again. */
+export function checkDue({ checkedAt, now, everyMs = EVERY_MS }) {
+  const last = Date.parse(checkedAt ?? "");
+  return !Number.isFinite(last) || now - last >= everyMs;
+}
+
+export async function readCachedCheck(dataHome, { readFile }) {
+  try {
+    const cached = JSON.parse(await readFile(cacheFile(dataHome), "utf8"));
+    return { latest: cached.latest ?? null, checkedAt: cached.checkedAt ?? null };
+  } catch {
+    // A missing or unreadable note is the same as never having asked.
+    return { latest: null, checkedAt: null };
+  }
+}
+
+export async function writeCachedCheck(dataHome, entry, { writeFile, mkdir }) {
+  const file = cacheFile(dataHome);
+  await mkdir(path.dirname(file), { recursive: true });
+  await writeFile(file, `${JSON.stringify(entry, null, 2)}\n`);
+}
+
+/** Ask the registry. The one network call in the product. */
+export async function fetchLatest({ get = fetch, url = REGISTRY,
+  timeoutMs = TIMEOUT_MS } = {}) {
+  const response = await get(url, { signal: AbortSignal.timeout(timeoutMs),
+    headers: { accept: "application/json" } });
+  if (response?.ok !== true) {
+    throw new AccError(EXIT.DATA, `the registry answered ${response?.status ?? "nothing"}`,
+      { url });
+  }
+  const body = await response.json();
+  if (typeof body?.version !== "string" || numbers(body.version).some(Number.isNaN)) {
+    throw new AccError(EXIT.DATA, "the registry did not answer with a version", { url });
+  }
+  return body.version;
+}
+
+/**
+ * What `acc doctor` says about a newer release, without becoming a network
+ * command.
+ *
+ * The answer is remembered for a day, so running the diagnostic twice does not
+ * ask twice. A registry that cannot be reached changes nothing: doctor is about
+ * this machine, and a network that is down is not a fault in this install.
+ */
+export async function noticeUpdate({ dataHome, running, env, now, get, io }) {
+  if (checkingIsOff(env)) return { checked: false, latest: null, newer: false };
+
+  const cached = await readCachedCheck(dataHome, io);
+  let latest = cached.latest;
+  if (checkDue({ checkedAt: cached.checkedAt, now })) {
+    try {
+      latest = await fetchLatest({ get });
+      await writeCachedCheck(dataHome,
+        { latest, checkedAt: new Date(now).toISOString() }, io);
+    } catch {
+      latest = cached.latest;
+    }
+  }
+  return { checked: true, latest: latest ?? null, newer: isNewer(latest, running) };
+}

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

@@ -0,0 +1,86 @@
+import { execFile } from "node:child_process";
+import { mkdir, writeFile } from "node:fs/promises";
+import { promisify } from "node:util";
+
+import { AccError, EXIT } from "@agents-can-communicate/protocol";
+
+import { platformPaths } from "./platform-paths.mjs";
+import { checkingIsOff, fetchLatest, isNewer, writeCachedCheck } from "./update-check.mjs";
+
+const execFileAsync = promisify(execFile);
+
+/**
+ * The two commands an upgrade takes, and why it is two.
+ *
+ * `npm install -g` replaces this CLI and the hook runtime, because the shim a
+ * client runs points into the npm directory rather than at a copy. It does not
+ * touch what was written into the client: its hook wiring, and the skills the
+ * agents read. Measured after an upgrade - the client still had `0.1.0` while
+ * `acc --version` said `0.1.1`, and nothing said so.
+ */
+export const upgradeSteps = version => [
+  ["npm", ["install", "--global", `agents-can-communicate@${version}`]],
+  ["acc", ["install"]],
+];
+
+const spell = ([command, argv]) => `  ${command} ${argv.join(" ")}`;
+
+export async function runUpdateCommand({ options, runtime }) {
+  const env = runtime.env ?? {};
+  const { data: dataHome } = platformPaths({ platform: runtime.platform, env });
+  const running = typeof runtime.version === "function"
+    ? await runtime.version().catch(() => null)
+    : null;
+
+  // Off means off, and it says so rather than reporting that nothing is newer -
+  // which is a different fact, and one this run did not establish.
+  if (checkingIsOff(env)) {
+    return { data: { checked: false, running, latest: null },
+      text: "update checking is off (ACC_NO_UPDATE_CHECK); nothing was asked" };
+  }
+
+  // Caught, and then refused rather than degraded. `doctor` and `install` can
+  // carry on without knowing which ACC is running - they say less - but this
+  // command is the comparison, and `isNewer(latest, null)` is false: carrying on
+  // would answer "you have the latest" on the strength of not knowing.
+  if (running === null) {
+    throw new AccError(EXIT.DATA,
+      "cannot read the installed version, so there is nothing to compare against");
+  }
+
+  const latest = await fetchLatest({ get: runtime.fetch });
+  await writeCachedCheck(dataHome, { latest, checkedAt: runtime.clock.now() },
+    { writeFile, mkdir });
+
+  if (!isNewer(latest, running)) {
+    return { data: { checked: true, running, latest, newer: false },
+      text: `acc ${running} is the latest` };
+  }
+
+  const steps = upgradeSteps(latest);
+  const data = { checked: true, running, latest, newer: true,
+    steps: steps.map(([command, argv]) => [command, ...argv].join(" ")) };
+
+  if (options.apply !== true) {
+    return { data, text: [`acc ${latest} is available; you have ${running}`, "",
+      ...steps.map(spell), "", "or run: acc update --apply"].join("\n") };
+  }
+
+  const spawn = runtime.spawn ?? ((command, argv) => execFileAsync(command, argv, { env }));
+  const done = [];
+  for (const [command, argv] of steps) {
+    try {
+      await spawn(command, argv);
+      done.push([command, ...argv].join(" "));
+    } catch (error) {
+      // Named rather than swallowed, and the rest of the commands are printed:
+      // a global install refused for want of permission is the ordinary case,
+      // and the person can finish it by hand from here.
+      return { data: { ...data, applied: done, failed: [command, ...argv].join(" ") },
+        text: [`${command} failed: ${error.message}`, "", "finish it with:",
+          ...steps.slice(done.length).map(spell)].join("\n"),
+        error: undefined };
+    }
+  }
+  return { data: { ...data, applied: done }, text: `updated to ${latest}` };
+}

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

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

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

@@ -12,7 +12,8 @@ import { recordInstall, removeOwned } from "./ownership.mjs";
  * A failure does not end the run. Someone installing four clients wants the
  * three that work, plus the name of the one that did not.
  */
-export async function applyPlan({ plan, adapters, context, dataHome, dryRun = false }) {
+export async function applyPlan({ plan, adapters, context, dataHome, dryRun = false,
+  accVersion = null }) {
   const byId = new Map(adapters.map(adapter => [adapter.id, adapter]));
   const results = { action: plan.action, dryRun, operations: [], skipped: plan.skipped,
     failed: [] };
@@ -34,7 +35,8 @@ export async function applyPlan({ plan, adapters, context, dataHome, dryRun = fa
         // did not happen. The reverse order would leave uninstall trying to
         // remove files nothing created.
         await recordInstall({ dataHome, adapterId: adapter.id,
-          version: operation.clientVersion ?? null, artifacts: operation.artifacts });
+          version: operation.clientVersion ?? null, accVersion,
+          artifacts: operation.artifacts });
         results.operations.push({ ...operation, applied: true,
           changes: outcome.changes ?? [], diagnostics: outcome.diagnostics ?? [] });
       } else {

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

@@ -102,7 +102,14 @@ async function saveOwnership({ dataHome, record }) {
  * second run's record describes what is actually on disk now, and an accumulated
  * one would list artifacts from a layout that no longer exists.
  */
-export async function recordInstall({ dataHome, adapterId, version, artifacts }) {
+/**
+ * @param version the client's version, as detected. `accVersion` is ACC's own,
+ * which is what tells a later run that the plugin in the client is older than
+ * the code now running: updating the npm package replaces the CLI and the hook
+ * runtime, and leaves the bundle inside the client exactly where it was.
+ */
+export async function recordInstall({ dataHome, adapterId, version, accVersion = null,
+  artifacts }) {
   const stamped = await Promise.all(artifacts.map(async artifact => ({
     path: artifact.path,
     kind: artifact.kind ?? "file",
@@ -113,7 +120,7 @@ export async function recordInstall({ dataHome, adapterId, version, artifacts })
   const record = await loadOwnership({ dataHome });
   await saveOwnership({ dataHome, record: { schemaVersion: SCHEMA_VERSION,
     installs: [...record.installs.filter(install => install.adapterId !== adapterId),
-      { adapterId, version, artifacts: stamped }] } });
+      { adapterId, version, accVersion, artifacts: stamped }] } });
 }
 
 const installFor = (record, adapterId) =>

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

@@ -7,11 +7,16 @@ import { AccError, EXIT } from "@agents-can-communicate/protocol";
  * makes `--dry-run` worth reading - a plan computed differently from the thing
  * it previews is a decoration, and the operator would find out only afterwards.
  */
-export function planInstallation({ adapters, detected, context, action = "install" }) {
+export function planInstallation({ adapters, detected, context, action = "install",
+  recorded = [] }) {
   if (!["install", "uninstall"].includes(action)) {
     throw new AccError(EXIT.USAGE, `unknown installation action: ${action}`, { action });
   }
   const byId = new Map(adapters.map(adapter => [adapter.id, adapter]));
+  // What ACC recorded writing, by client. For an uninstall this is the
+  // 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]));
   const operations = [];
   const skipped = [];
 
@@ -24,20 +29,32 @@ export function planInstallation({ adapters, detected, context, action = "instal
       skipped.push({ adapterId: entry.adapterId, reason: "no adapter for this client" });
       continue;
     }
-    if (!entry.present) {
+    // A client that has left the machine is still worth visiting when ACC wrote
+    // to it. Skipping it made that install permanently unremovable: `acc
+    // uninstall` reported success and exit 0, left ACC's tree in the client's
+    // configuration directory and ACC's entries in the user's own settings
+    // file, and said the same thing on every run afterwards.
+    const record = action === "uninstall" && !entry.present
+      ? recordedById.get(entry.adapterId)
+      : undefined;
+
+    if (!entry.present && record === undefined) {
       // Named rather than dropped: "nothing happened" and "that client is not
       // installed on this machine" look the same in an empty list.
       skipped.push({ adapterId: entry.adapterId,
         reason: `${entry.displayName ?? entry.adapterId} is not installed on this machine` });
       continue;
     }
-    if (typeof adapter.planInstall !== "function") {
+    if (record === undefined && typeof adapter.planInstall !== "function") {
       skipped.push({ adapterId: entry.adapterId,
         reason: "this adapter cannot describe what it would write" });
       continue;
     }
 
-    const artifacts = adapter.planInstall(context)
+    // From the record when the client is gone, because that is what was written
+    // and so what will be removed. Asking the adapter instead would describe an
+    // install for a machine this one no longer is.
+    const artifacts = (record?.artifacts ?? adapter.planInstall(context))
       .map(artifact => ({ path: artifact.path, kind: artifact.kind ?? "file" }))
       .sort((a, b) => a.path.localeCompare(b.path));
 
@@ -45,12 +62,18 @@ export function planInstallation({ adapters, detected, context, action = "instal
       adapterId: adapter.id,
       displayName: adapter.displayName,
       action,
-      clientVersion: entry.version ?? null,
+      clientVersion: entry.version ?? record?.version ?? null,
+      // "Remove these files for a client that is not here" is a different thing
+      // to approve than an ordinary uninstall, so it is said rather than left
+      // to be inferred from a client version that is null.
+      clientPresent: entry.present === true,
       alreadyInstalled: entry.installed === true,
       artifacts,
       // Said in the operator's terms, not in paths: which files ACC creates
       // outright and which belong to the user and are only edited.
       summary: [
+        ...(entry.present ? [] : [`${adapter.displayName ?? adapter.id} is no longer on `
+          + "this machine; removing what ACC recorded writing"]),
         ...artifacts.filter(a => a.kind === "tree")
           .map(a => `${action === "install" ? "create" : "remove"} ${a.path}`),
         ...artifacts.filter(a => a.kind === "merge")

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-can-communicate",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "type": "module",
   "description": "Model- and harness-agnostic coordination for independent AI agent sessions.",
   "keywords": [
@@ -36,9 +36,9 @@
     "node": ">=24"
   },
   "bin": {
-    "acc": "./bin/acc.mjs",
-    "acc-mcp": "./bin/acc-mcp.mjs",
-    "acc-hook": "./bin/acc-hook.mjs"
+    "acc": "bin/acc.mjs",
+    "acc-mcp": "bin/acc-mcp.mjs",
+    "acc-hook": "bin/acc-hook.mjs"
   },
   "files": [
     "bin/",