agents-can-communicate 0.7.0 → 0.8.0

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

@@ -2,7 +2,7 @@ import { describeInstallDelivery } from "./delivery-diagnostics.mjs";
 
 import { AccError, EXIT } from "@agents-can-communicate/protocol";
 
-import { LIVE_POLICIES, describeActivation, describeDeactivation, planActivationRetirements, rcFileFor, shimDirFor }
+import { LIVE_POLICIES, describeActivation, describeDeactivation, planActivationRetirements }
   from "./native-activation.mjs";
 
 /**
@@ -122,8 +122,18 @@ export function planInstallation({ adapters, detected, context, action = "instal
       && native.activationPlan?.eligible === true;
     const effectiveLivePolicy = liveDeliverySupported ? delivery : "off";
     const previous = recordedById.get(entry.adapterId)?.nativeActivation ?? null;
+    // What a failed readiness probe may keep. Not a shell bootstrap: no adapter
+    // can plan one any more, so keeping it would keep a launch path nothing
+    // maintains - the 0.7.x `claude` shim. Not an activation recorded under a
+    // contract the adapter no longer declares: it describes a transport that is
+    // gone, the Claude Channel among them.
+    const declaredContracts = new Set((adapter.nativeDelivery?.anchors ?? [])
+      .map(anchor => anchor.protocolContract));
+    const retainable = previous !== null && declaredContracts.has(previous.protocolContract)
+      ? { ...previous, mechanisms: (previous.mechanisms ?? []).filter(item => item.kind !== "shell-bootstrap") }
+      : null;
     const retainedActivation = action === "install" && delivery !== "off"
-      && !liveDeliverySupported && previous?.livePolicy === delivery ? previous : null;
+      && !liveDeliverySupported && retainable?.livePolicy === delivery ? retainable : null;
     const configuredLivePolicy = retainedActivation ? delivery : effectiveLivePolicy;
     const deliveryDiagnostic = action === "install" && delivery !== "off"
       && !liveDeliverySupported
@@ -144,13 +154,13 @@ export function planInstallation({ adapters, detected, context, action = "instal
     // creates one.
     const nativeActivation = action === "install" && effectiveLivePolicy !== "off"
       ? { livePolicy: effectiveLivePolicy, protocolContract: native.eligibility.protocolContract,
-        shell: context?.shell ?? null, rcFile: rcFileFor(context?.home, context?.shell),
-        shimDir: typeof context?.stateRoot === "string" ? shimDirFor(context.stateRoot) : null,
         mechanisms: native.activationPlan.mechanisms }
       : null;
     // A failed readiness probe is not revocation. Keep existing guarded launch
     // setup without applying service commands or claiming it is available.
-    const retirements = retainedActivation ? [] : planActivationRetirements({ previous, desired: nativeActivation });
+    const retirements = retainedActivation
+      ? (previous.mechanisms ?? []).filter(item => item.kind === "shell-bootstrap")
+      : planActivationRetirements({ previous, desired: nativeActivation });
     const deactivation = retirements.length > 0 ? { ...previous, mechanisms: retirements } : null;
     const artifacts = (record?.artifacts ?? adapter.planInstall(installContext))
       .map(artifact => ({ path: artifact.path, kind: artifact.kind ?? "file" }))

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

@@ -1,115 +1,19 @@
 import { createHash } from "node:crypto";
-import { chmod, mkdir, readdir, readFile, rename, rm, rmdir, writeFile } from "node:fs/promises";
+import { chmod, readdir, readFile, rename, rm, rmdir, stat, writeFile } from "node:fs/promises";
 import path from "node:path";
 
-import { AccError, EXIT, assertPortableId } from "@agents-can-communicate/protocol";
-
-// The reversible shell half of native delivery: one marked PATH block in the
-// user's zsh rc and one per-command shim in an ACC-owned directory. The shim
-// keeps the user's command name, runs the bounded bootstrap check, and then
-// replaces itself with the real vendor executable through `exec`; ACC is never
-// the parent of a model session. Every byte ACC writes is recorded with its
-// hash so uninstall removes only what is still ACC's and refuses a block or
-// shim someone has edited.
+// Retirement of the shell half of 0.7.x native delivery: one marked PATH block
+// in the user's zsh rc and one `claude` shim in an ACC-owned directory. ACC no
+// longer writes either; `acc install`, `acc update` and `acc uninstall` remove
+// what an older version wrote. Every byte was recorded with its hash, so only
+// what is still ACC's is removed, and an edited block or shim is kept.
 
 export const BLOCK_BEGIN = "# >>> agents-can-communicate native delivery >>>";
 export const BLOCK_END = "# <<< agents-can-communicate native delivery <<<";
 export const SHIM_MARKER = "# agents-can-communicate native delivery shim";
-export const SUPPORTED_SHELLS = Object.freeze(["zsh"]);
-export const SHIM_POLICIES = Object.freeze(["actionable", "all"]);
-const COMMAND_NAME = /^[a-z][a-z0-9_.-]*$/;
 
-const usage = (message, details = {}) => { throw new AccError(EXIT.USAGE, message, details); };
 const sha256 = text => createHash("sha256").update(text).digest("hex");
-// Single-quoted POSIX literal: the only escaping is the quote itself, so no
-// byte of a path or argument is ever interpreted by the shell.
-export const shellLiteral = value => `'${String(value).replaceAll("'", "'\\''")}'`;
-const isAbsolute = value => typeof value === "string" && path.isAbsolute(value);
-const inside = (root, candidate) => {
-  const relative = path.relative(root, candidate);
-  return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
-};
-
-export function renderPathBlock(shimDir) {
-  return `${BLOCK_BEGIN}\nexport PATH=${shellLiteral(shimDir)}:"$PATH"\n${BLOCK_END}\n`;
-}
-
-export function validateShimEntry(entry) {
-  if (entry === null || typeof entry !== "object") usage("a shim entry must be an object");
-  for (const key of Object.keys(entry)) {
-    if (!["adapterId", "command", "realExecutable", "prefixArgs", "livePolicy"].includes(key)) {
-      usage(`unknown shim entry field ${key}`, { key });
-    }
-  }
-  assertPortableId(entry.adapterId, "shim adapter id");
-  if (typeof entry.command !== "string" || !COMMAND_NAME.test(entry.command)) {
-    usage("a shim command must be a bare command name", { command: entry.command });
-  }
-  if (!isAbsolute(entry.realExecutable)) usage("a shim realExecutable must be an absolute path");
-  if (!Array.isArray(entry.prefixArgs) || entry.prefixArgs.some(arg => typeof arg !== "string"
-    || arg === "" || /[\0\n]/.test(arg))) {
-    usage("shim prefixArgs must be non-empty argument strings without NUL or newline");
-  }
-  if (!SHIM_POLICIES.includes(entry.livePolicy)) {
-    usage("a shim livePolicy must be actionable or all; off means no shim", { livePolicy: entry.livePolicy });
-  }
-  return Object.freeze({ ...entry, prefixArgs: Object.freeze([...entry.prefixArgs]) });
-}
-
-export function renderCommandShim({ node, bootstrap, dataHome, entry }) {
-  const shim = validateShimEntry(entry);
-  for (const [name, value] of Object.entries({ node, bootstrap, dataHome })) {
-    if (!isAbsolute(value)) usage(`shim ${name} must be an absolute path`, { [name]: value });
-  }
-  const real = shellLiteral(shim.realExecutable);
-  const check = [node, bootstrap, "--adapter", shim.adapterId, "--real-executable",
-    shim.realExecutable, "--data-home", dataHome].map(shellLiteral).join(" ");
-  const prefix = shim.prefixArgs.map(shellLiteral).join(" ");
-  return [
-    "#!/bin/sh",
-    `${SHIM_MARKER} for ${shellLiteral(shim.command)}. Generated; do not edit.`,
-    "# ACC_BYPASS=1 runs the vendor command untouched. A failed or missing check",
-    "# does the same: the vendor command is never blocked on ACC.",
-    'if [ "${ACC_BYPASS-}" = "1" ]; then',
-    "  unset ACC_NATIVE_DELIVERY_POLICY",
-    `  exec ${real} "$@"`,
-    "fi",
-    `if ${check} </dev/null >/dev/null 2>&1; then`,
-    `  ACC_NATIVE_DELIVERY_POLICY=${shellLiteral(shim.livePolicy)}`,
-    "  export ACC_NATIVE_DELIVERY_POLICY",
-    `  exec ${real}${prefix === "" ? "" : ` ${prefix}`} "$@"`,
-    "fi",
-    "unset ACC_NATIVE_DELIVERY_POLICY",
-    `exec ${real} "$@"`,
-    "",
-  ].join("\n");
-}
-
-export function planShellBootstrap({ shell, rcFile, shimDir, entries = [], runtime = null }) {
-  if (!SUPPORTED_SHELLS.includes(shell)) {
-    return Object.freeze({ eligible: false, reasonCode: "unsupported_shell", shell: shell ?? null,
-      rcFile: null, shimDir: null, block: null, shims: Object.freeze([]), runtime: null });
-  }
-  if (!isAbsolute(rcFile) || !isAbsolute(shimDir)) usage("rcFile and shimDir must be absolute");
-  const validated = entries.map(validateShimEntry);
-  const commands = new Set();
-  for (const entry of validated) {
-    if (commands.has(entry.command)) usage(`duplicate shim command ${entry.command}`);
-    commands.add(entry.command);
-    // A shim that resolved to itself would loop forever; the real executable
-    // is resolved before the shim directory is ever on PATH.
-    if (inside(shimDir, entry.realExecutable)) {
-      usage("a shim realExecutable cannot live inside the shim directory",
-        { realExecutable: entry.realExecutable });
-    }
-  }
-  return Object.freeze({ eligible: true, reasonCode: null, shell, rcFile, shimDir,
-    block: renderPathBlock(shimDir), runtime,
-    shims: Object.freeze(validated.map(entry => Object.freeze({
-      path: path.join(shimDir, entry.command), entry }))) });
-}
-
-const defaultIo = Object.freeze({ readFile, writeFile, mkdir, chmod, rename, rm, rmdir, readdir });
+const defaultIo = Object.freeze({ readFile, writeFile, chmod, rename, rm, rmdir, readdir, stat });
 
 async function readText(io, file) {
   try {
@@ -139,35 +43,6 @@ export function locateBlock(text) {
   return { start: begin, end: end === -1 ? text.length : end + 1 };
 }
 
-export async function installShellBootstrap({ plan, io = defaultIo }) {
-  if (!plan?.eligible) return { ok: false, reasonCode: plan?.reasonCode ?? "unsupported_shell" };
-  const { node, bootstrap, dataHome } = plan.runtime ?? {};
-  const current = await readText(io, plan.rcFile);
-  const span = locateBlock(current);
-  const existing = span === null ? null : current.slice(span.start, span.end);
-  if (existing !== null && existing !== plan.block) {
-    return { ok: false, reasonCode: "rc_block_modified", rcFile: plan.rcFile };
-  }
-  await io.mkdir(plan.shimDir, { recursive: true, mode: 0o700 });
-  await io.chmod(plan.shimDir, 0o700);
-  const shims = [];
-  for (const shim of plan.shims) {
-    const content = renderCommandShim({ node, bootstrap, dataHome, entry: shim.entry });
-    await writeAtomic(io, shim.path, content, 0o700);
-    shims.push({ path: shim.path, command: shim.entry.command, sha256: sha256(content) });
-  }
-  let appended = false;
-  if (existing === null) {
-    const base = current ?? "";
-    const separator = base === "" || base.endsWith("\n") ? "" : "\n";
-    await writeAtomic(io, plan.rcFile, `${base}${separator}${plan.block}`, 0o600);
-    appended = true;
-  }
-  return { ok: true, reasonCode: null, shell: plan.shell, shimDir: plan.shimDir,
-    rcFile: { path: plan.rcFile, blockSha256: sha256(plan.block), appended },
-    shims };
-}
-
 export async function uninstallShellBootstrap({ ownership, io = defaultIo }) {
   const result = { ok: true, reasonCode: null, removedShims: [], keptShims: [],
     missingShims: [], rcBlock: "absent" };
@@ -199,7 +74,9 @@ export async function uninstallShellBootstrap({ ownership, io = defaultIo }) {
     } else if (remaining.length > 0) {
       result.rcBlock = "kept";
     } else {
-      await writeAtomic(io, rcFile.path, text.slice(0, span.start) + text.slice(span.end), 0o600);
+      // The user's file keeps the permissions it has now.
+      const mode = ((await io.stat?.(rcFile.path).catch(() => null))?.mode ?? 0o600) & 0o777;
+      await writeAtomic(io, rcFile.path, text.slice(0, span.start) + text.slice(span.end), mode);
       result.rcBlock = "removed";
     }
   }

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/mcp-server",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "private": true,
   "type": "module",
   "exports": {

package/node_modules/@agents-can-communicate/mcp-server/src/tools.mjs

@@ -23,15 +23,17 @@ const stringList = description => ({ type: "array", items: { type: "string" }, d
 export const PUBLIC_TOOLS = Object.freeze([
   {
     name: "acc_status",
-    description: `Read who is here, current intents and claims, and the workspace's real `
-      + `protection level. ${POLLED}`,
+    description: `Read who is here, current intents and claims, the workspace's real `
+      + `protection level, and how many messages each participant has not fetched `
+      + `(offered is not read). ${POLLED}`,
     inputSchema: object({}),
   },
   {
     name: "acc_sync",
     description: `Read coordination state for this workspace: roster, attention items, and `
       + `events since a cursor. Use scope "history" for bounded message summaries, then `
-      + `messageId to read one complete historical message without changing receipts. `
+      + `messageId to read one complete historical message, with every recipient's `
+      + `receipt state, without changing receipts. `
       + `Scope "full" is an unbounded forensic workspace snapshot. Use acc_inbox for `
       + `your addressed messages. ${POLLED}`,
     inputSchema: object({

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/protocol",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "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.7.0",
+  "version": "0.8.0",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -72,11 +72,16 @@ export async function publishAtomic(destination, bytes,
   // active-journal.mjs defaults tmpDir, so every caller keeps working.
   stageDir = stageDir ?? path.join(root, "stage");
   const destinationDir = path.dirname(destination);
-  await Promise.all([
+  // Every check settles before a refusal is reported: Promise.all would reject
+  // on the first one while the others still create directories under a root
+  // the caller may already be removing.
+  const prepared = await Promise.allSettled([
     ensureManagedDirectory(root, tmpDir),
     ensureManagedDirectory(root, stageDir),
     ensureManagedDirectory(root, destinationDir),
   ]);
+  const refused = prepared.find(result => result.status === "rejected");
+  if (refused) throw refused.reason;
   if (!replace) {
     const existing = await bytesIfPresent(destination, root);
     if (existing !== null) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-can-communicate",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "accManagedUpdateProtocol": 2,
   "accStoreVersion": 6,
   "type": "module",

package/bin/acc-bootstrap.mjs

@@ -1,7 +0,0 @@
-#!/usr/bin/env node
-import { fileURLToPath } from "node:url";
-import { invokedDirectly, runEntry } from "@agents-can-communicate/cli/managed-entry";
-
-if (invokedDirectly(import.meta.url)) await runEntry({
-  kind: "acc-bootstrap", packageRoot: fileURLToPath(new URL("..", import.meta.url)),
-});

package/bin/acc-claude-channel.mjs

@@ -1,10 +0,0 @@
-#!/usr/bin/env node
-import { fileURLToPath } from "node:url";
-import { invokedDirectly, runEntry } from "@agents-can-communicate/cli/managed-entry";
-export const resolveSession = async options => (await import("./entrypoints/acc-claude-channel.mjs")).resolveSession(options);
-export const ownClient = async options => (await import("./entrypoints/acc-claude-channel.mjs")).ownClient(options);
-export const resolveWithin = async options => (await import("./entrypoints/acc-claude-channel.mjs")).resolveWithin(options);
-
-if (invokedDirectly(import.meta.url)) await runEntry({
-  kind: "acc-claude-channel", packageRoot: fileURLToPath(new URL("..", import.meta.url)),
-});

package/bin/entrypoints/claude-channel-binding.mjs

@@ -1,46 +0,0 @@
-import { createClaudeCodeAdapter } from "@agents-can-communicate/adapter-claude-code";
-import { loadSessionBinding, storeNativeAttempt } from "@agents-can-communicate/adapter-sdk";
-import { createCoordinationService } from "@agents-can-communicate/core";
-import { establishNativeBinding, livePolicyFrom } from "@agents-can-communicate/hook-runner/native-binding";
-import { withSessionLifecycle } from "@agents-can-communicate/hook-runner/session-lifecycle";
-import { readInstalledLivePolicy } from "@agents-can-communicate/installer";
-import { openFilesystemStore } from "@agents-can-communicate/storage-filesystem";
-
-// SessionStart cannot wait for MCP indefinitely. The endpoint's owner completes
-// the same handshake when it starts later, without a prompt or an LLM turn.
-// Serialize with the hooks, then reread ownership: a queued startup must never
-// publish for a replaced/closed session or undo SessionEnd's retirement.
-export async function activateClaudeChannel({ session, service, runtimeDir, dataHome, env,
-  deadlineAt = Date.now() + 5_000 }) {
-  if (typeof session.harnessSessionId !== "string") return null;
-  return withSessionLifecycle({ root: runtimeDir, sessionId: session.harnessSessionId,
-    clock: service.clock, deadlineAt }, async () => {
-    // A prior hook can die after committing its journal. Recover that close
-    // before reading ownership, just as the hook runner does under this lock.
-    const { clock, ids } = service;
-    const store = await openFilesystemStore({ root: runtimeDir, clock, ids,
-      workspaceId: service.store.workspaceId, deadlineAt });
-    service = createCoordinationService({ store, clock, ids });
-    const current = await loadSessionBinding({ runtimeDir,
-      harnessSessionId: session.harnessSessionId });
-    if (current?.accSessionId !== session.sessionId || current.generation !== session.generation
-      || current.clientPid !== session.clientPid) return null;
-    const located = await service.locateSession(session.sessionId);
-    if (located?.record.state !== "open" || located.record.generation !== session.generation) return null;
-    const policy = livePolicyFrom(env);
-    if (policy === "off" || await readInstalledLivePolicy({ dataHome,
-      adapterId: "claude_code" }) === "off") return null;
-    if (Date.now() >= deadlineAt) return null;
-    const result = await establishNativeBinding({ adapter: createClaudeCodeAdapter(),
-      event: { kind: "channelReady", sessionId: session.harnessSessionId },
-      hookBinding: current, clientVersion: current.clientVersion, platform: current.platform,
-      livePolicy: policy, service, runtimeDir, clock: service.clock, env,
-      timeoutMs: Math.max(1, Math.min(750, deadlineAt - Date.now())) });
-    await storeNativeAttempt({ runtimeDir, harnessSessionId: session.harnessSessionId,
-      accSessionId: session.sessionId, generation: session.generation, deadlineAt,
-      nativeAttempt: { at: service.clock.now(), event: "channelReady", state: result.state,
-        reasonCode: result.reasonCode, policy, policySource: "bootstrap-environment",
-        policyStatus: "enabled", clientProcess: "identified" } });
-    return result;
-  });
-}

package/bin/entrypoints/claude-channel-stdio.mjs

@@ -1,29 +0,0 @@
-// Workspace-free MCP fallback shared by composition and managed admission failure.
-import { createInertChannel } from "@agents-can-communicate/adapter-claude-code/channel";
-
-export function startInertChannel({ write = payload => process.stdout.write(JSON.stringify(payload) + "\n") } = {}) {
-  const inert = createInertChannel({ write });
-  pump(inert.handleLine, () => process.exit(0));
-  return inert;
-}
-
-/** One line-delimited JSON pump, for the bound server and the unbound one alike. */
-export function pump(handleLine, shutdown) {
-  let buffer = "";
-  process.stdin.setEncoding("utf8");
-  process.stdin.on("data", async chunk => {
-    buffer += chunk;
-    let newline = buffer.indexOf("\n");
-    while (newline !== -1) {
-      const line = buffer.slice(0, newline).trim();
-      buffer = buffer.slice(newline + 1);
-      newline = buffer.indexOf("\n");
-      if (line !== "") await handleLine(line);
-    }
-  });
-  process.stdin.on("end", shutdown);
-  process.once("SIGTERM", shutdown);
-  process.once("SIGINT", shutdown);
-  // Keeps the child answerable for as long as Claude holds the transport open.
-  process.stdin.resume();
-}

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

@@ -1,8 +0,0 @@
-{
-  "mcpServers": {
-    "acc-channel": {
-      "command": "ACC_NODE_PLACEHOLDER",
-      "args": ["ACC_CHANNEL_PLACEHOLDER"]
-    }
-  }
-}