agents-can-communicate 0.1.10 → 0.1.12

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

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

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

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

@@ -68,8 +68,10 @@ export function createCodexAdapter() {
           "write guards cover apply_patch and the shell writes ACC can read; a model "
             + "without apply_patch edits through the shell, where a redirection or an "
             + "mv is matched and a runtime opening the file is not",
-          "Codex requires hooks to be trusted before they run; an untrusted plugin is "
-            + "installed but inert",
+          // Was a standing sentence here, true and useless: it said the same
+          // thing on a machine whose hooks were trusted, on one whose were not,
+          // and on one with nothing installed. Detection reads the client's own
+          // record now and speaks only when it has something to report.
         ],
       };
     },

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

@@ -238,33 +238,6 @@ async function removeEmptyDirs(directories) {
   }
 }
 
-/**
- * Drop the client's trust record for hooks that are about to stop existing.
- *
- * Scoped to tables whose key begins with ACC's own `plugin@marketplace:` - a
- * table belonging to any other plugin is the client's business and stays. The
- * file is rewritten only when something was found, so an install that never ran
- * here leaves the config byte for byte as it was.
- */
-export async function removeHookTrust(file, prefix) {
-  const before = await readFile(file, "utf8").catch(() => null);
-  if (before === null || !before.includes(`hooks.state."${prefix}`)) return false;
-
-  const lines = before.split("\n");
-  const kept = [];
-  let dropping = false;
-  for (const line of lines) {
-    const header = /^\s*\[([^\]]*)\]\s*$/.exec(line);
-    if (header !== null) dropping = header[1].startsWith(`hooks.state."${prefix}`);
-    if (dropping) continue;
-    kept.push(line);
-  }
-  // A table's trailing blank line goes with it rather than piling up.
-  const text = kept.join("\n").replace(/\n{3,}/g, "\n\n");
-  if (text === before) return false;
-  await writeFile(file, text, "utf8");
-  return true;
-}
 
 export async function uninstallCodexPlugin({ home, agentsHome = home,
   codexHome = path.join(home, ".codex"), keep = [] }) {
@@ -277,15 +250,18 @@ export async function uninstallCodexPlugin({ home, agentsHome = home,
     await writeMarketplace(file, { ...existing, plugins: kept });
   }
   if (await removeTomlBlock(configPath(codexHome))) changes.push(configPath(codexHome));
-  // This client keeps its own record of which hook files it has trusted, one
-  // table per hook, keyed by the plugin that declared them. ACC never writes
-  // those - they are the client's bookkeeping about ACC - but once the plugin is
-  // gone they name a thing that does not exist, five of them per install, and
-  // nothing else will ever clear them. Verified inert first: a hook whose hash
-  // no longer matches still runs, so this is tidiness rather than repair.
-  if (await removeHookTrust(configPath(codexHome), `${PLUGIN_NAME}@${MARKETPLACE}:`)) {
-    if (!changes.includes(configPath(codexHome))) changes.push(configPath(codexHome));
-  }
+  // The client's `[hooks.state."<plugin>:…"]` tables stay. 0.1.9 removed them as
+  // litter naming a plugin that was gone; that was wrong, and wrong in a way
+  // worth writing down. The check behind it perturbed the record - a hook whose
+  // recorded hash no longer *matched* was seen still running - and concluded the
+  // record was inert. Absence was never tested, and absence is what matters:
+  // with the tables gone this client runs no hook at all, prints
+  // `hook: SessionStart Completed` while executing nothing, and ACC's write
+  // guard is silently off while `acc doctor` reports the adapter installed.
+  //
+  // The record is granted once, by a person, and survives ACC upgrades - hashes
+  // captured under 0.1.6 still admitted 0.1.10's hooks. Nothing ACC writes can
+  // put it back. So it is not ACC's to remove.
   // The marketplace directory is ACC's too, so it goes rather than being left
   // behind empty.
   // A blank TOML config and an absent one are the same to this client, and a
@@ -328,6 +304,13 @@ export async function detectCodex({ home, agentsHome = home,
   const enabled = config.includes(`[plugins."${QUALIFIED}"]`);
   const cached = await stat(cachePath(codexHome))
     .then(() => true).catch(() => false);
+  // The condition that decides whether ACC runs here at all, and the only one
+  // this client will not tell you about: with no trust record it runs no hook,
+  // prints `hook: SessionStart Completed`, and executes nothing. Everything else
+  // - published, registered, enabled, cached - can be true while the write guard
+  // is off. Only asked when something is wired: a warning about hooks that do
+  // not exist is how a real one gets ignored.
+  const untrusted = cached && !config.includes(`hooks.state."${QUALIFIED}:`);
   return { ok: true, changes: [], diagnostics: [
     published ? "acc plugin published in the marketplace" : "acc plugin not registered",
     registered && enabled
@@ -339,7 +322,25 @@ export async function detectCodex({ home, agentsHome = home,
     cached
       ? "plugin installed in the client's cache"
       : `plugin not installed yet; run: codex plugin add ${QUALIFIED}`,
-  ] };
+    // The condition that decides whether ACC runs here at all, and the only one
+    // this client will not tell you about: with no trust record it runs no hook,
+    // prints `hook: SessionStart Completed`, and executes nothing. Everything
+    // else - published, registered, enabled, cached - can be true while the
+    // write guard is off. Said only when there is something to trust, because a
+    // warning on a machine with nothing wired is how a real one gets ignored.
+    ...(untrusted
+      ? ["hooks are not trusted, so this client reports them completed and runs "
+        + "nothing"]
+      : []),
+  ],
+  // Said as an action rather than an observation, because a person has to do it
+  // and no acc command can: the client grants this once, from its own prompt.
+  // A diagnostic alone would have stayed in `--json`, which is where the first
+  // version of this fix put it and where nobody would have read it.
+  needsAction: untrusted
+    ? ["start codex once and accept the hook trust prompt  "
+      + "# its hooks run nothing until then"]
+    : [] };
 }
 
 /**

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -44,7 +44,8 @@ export async function detectInstallation({ adapters, context, probe = spawnProbe
     .map(async adapter => {
       const entry = { adapterId: adapter.id, displayName: adapter.displayName,
         present: false, version: null, versionOutput: null, installed: false,
-        diagnostics: [], capabilities: adapter.capabilities ?? {}, error: null };
+        diagnostics: [], needsAction: [], capabilities: adapter.capabilities ?? {},
+        error: null };
 
       try {
         const output = await withTimeout(
@@ -65,6 +66,9 @@ export async function detectInstallation({ adapters, context, probe = spawnProbe
       try {
         const detected = await adapter.detect(context);
         entry.diagnostics = detected.diagnostics ?? [];
+        // What a person has to do, as opposed to what is true. Adapters that
+        // have nothing to ask for say nothing.
+        entry.needsAction = detected.needsAction ?? [];
         // "Installed" is the adapter's own answer, phrased in its own terms.
         // The installer does not second-guess it by looking at files it does
         // not understand.

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

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

package/package.json

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