agents-can-communicate 0.1.0 → 0.1.1

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.1",
   "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.1",
   "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.1",
   "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.1",
   "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.1",
   "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.1",
   "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.1",
   "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.1",
   "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.1",
   "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/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.1",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -57,7 +57,10 @@ export const COMMANDS = Object.freeze({
   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"] },
+  // `--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", "yes"] },
   // 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/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";
 
@@ -80,6 +80,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();
@@ -88,12 +103,18 @@ export async function runInstallCommand({ options, runtime, action = "install" }
     env: runtime.env ?? {} });
 
   const detected = await detectInstallation({ adapters, context });
-  const plan = planInstallation({ adapters, detected, context, action });
+  // 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 });
 
-  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),

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.1",
   "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.1",
   "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.1",
   "private": true,
   "type": "module",
   "exports": { ".": "./src/index.mjs" },

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.1",
   "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.1",
   "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.1",
   "private": true,
   "type": "module",
   "exports": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-can-communicate",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "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/",