agents-can-communicate 0.7.1 → 0.8.1

package/node_modules/@agents-can-communicate/hook-runner/src/process-table.mjs

@@ -8,27 +8,43 @@ const run = promisify(execFile);
 const DEFAULT_TIMEOUT_MS = 1_000;
 
 const LINE = /^\s*(\d+)\s+(\d+)\s+(.+?)\s*$/;
+// A pid, then the whole rest of the line: a command line has spaces anywhere.
+const ARGS_LINE = /^\s*(\d+)\s+(.+?)\s*$/;
+// Command lines are long; measured at 231 KB for 1,137 processes on a desktop
+// Mac, a quarter of execFile's default buffer.
+const ARGS_BUFFER = 16 * 1024 * 1024;
 
 /**
- * Every process on this machine, as pid -> parent and executable.
+ * Every process on this machine, as pid -> parent, executable and, when it
+ * could be read, command line.
  *
  * Returns an empty map rather than throwing when the platform has no `ps`
  * (Windows) or the call fails. An empty table resolves no client, which is the
- * "nobody knows" answer the caller already handles.
+ * "nobody knows" answer the caller already handles. The command lines are read
+ * at the same time and within the same timeout; they only name a client that
+ * is a script, so when that read fails every entry keeps what it had before.
  */
 export async function readProcessTable({ run: exec = run,
   timeoutMs = DEFAULT_TIMEOUT_MS } = {}) {
-  try {
-    const { stdout } = await exec("ps", ["-o", "pid=,ppid=,comm=", "-A"],
-      { timeout: timeoutMs, killSignal: "SIGKILL" });
-    const table = new Map();
-    for (const line of stdout.split("\n")) {
-      const match = LINE.exec(line);
-      if (match === null) continue;
-      table.set(Number(match[1]), { ppid: Number(match[2]), comm: match[3] });
-    }
-    return table;
-  } catch {
-    return new Map();
+  const options = { timeout: timeoutMs, killSignal: "SIGKILL" };
+  const [tree, commandLines] = await Promise.all([
+    exec("ps", ["-o", "pid=,ppid=,comm=", "-A"], options).then(({ stdout }) => stdout, () => null),
+    exec("ps", ["-A", "-o", "pid=,args="], { ...options, maxBuffer: ARGS_BUFFER })
+      .then(({ stdout }) => stdout, () => ""),
+  ]);
+  if (typeof tree !== "string") return new Map();
+  const args = new Map();
+  for (const line of String(commandLines).split("\n")) {
+    const match = ARGS_LINE.exec(line);
+    if (match !== null) args.set(Number(match[1]), match[2]);
   }
+  const table = new Map();
+  for (const line of tree.split("\n")) {
+    const match = LINE.exec(line);
+    if (match === null) continue;
+    const pid = Number(match[1]);
+    table.set(pid, { ppid: Number(match[2]), comm: match[3],
+      ...(args.has(pid) ? { args: args.get(pid) } : {}) });
+  }
+  return table;
 }

package/node_modules/@agents-can-communicate/hook-runner/src/runner.mjs

@@ -400,8 +400,10 @@ const HANDLERS = {
       const facts = await runtimeFacts(import.meta.url);
       await storeSessionBinding({ runtimeDir: paths.root, deadlineAt: deadline, harnessSessionId: event.sessionId,
         accSessionId: binding.accSessionId, generation: binding.generation, ...facts });
+      // The pid this binding already knew keeps the refreshed pin reapable if
+      // the lookup below cannot find the client.
       await writePin({ root: pinRoot, harnessSessionId: event.sessionId, runtimeRoot: facts.runtimeRoot,
-        version: facts.version, storeVersion: facts.storeVersion });
+        version: facts.version, storeVersion: facts.storeVersion, clientPid: binding.clientPid });
     }
     const clientVersion = await probeClientVersion(adapter,
       { timeoutMs: Math.max(1, Math.min(1_000, deadline - Date.now())) });
@@ -506,7 +508,7 @@ const HANDLERS = {
     const owner = { sessionId: binding.accSessionId, generation: binding.generation };
     const current = await context.service.locateSession(binding.accSessionId);
     if (current?.record.generation === binding.generation && current.record.state === "open") {
-      await context.service.closeSession(owner);
+      await context.service.closeSession({ ...owner, endReason: event.endReason ?? null });
     } else {
       // Close may have committed before this hook died. Retire only the old
       // endpoint and binding; do not close a replacement or repeat a close event.

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/installer",
-  "version": "0.7.1",
+  "version": "0.8.1",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -1,3 +1,6 @@
+import { readdir, rm } from "node:fs/promises";
+import path from "node:path";
+
 import { applyServiceSetup } from "./service-setup.mjs";
 import { applyNativeActivation, deactivateNative } from "./native-activation.mjs";
 import { finalizeRemoval, missingArtifactParents, recordInstall,
@@ -52,12 +55,10 @@ export async function applyPlan({ plan, adapters, context, dataHome, dryRun = fa
           retainedMechanisms = report.retainedMechanisms;
         }
         let native = operation.retainedNativeActivation ?? null;
-        let appendedRcBlock = false;
         if (operation.nativeActivation !== undefined) {
-          const applied = await applyNativeActivation({ adapter,
-            activation: operation.nativeActivation, dataHome, ...activation });
+          const applied = await applyNativeActivation({
+            activation: operation.nativeActivation, ...activation });
           native = applied.nativeActivation;
-          appendedRcBlock = applied.appendedRcBlock;
         }
         if (retainedMechanisms.length > 0) {
           native = { ...(native ?? operation.deactivation),
@@ -71,7 +72,7 @@ export async function applyPlan({ plan, adapters, context, dataHome, dryRun = fa
           artifacts: operation.artifacts, createdDirectories,
           deliveryPolicy: operation.livePolicy, deliveryDecision: operation.deliveryDecision,
           nativeActivation: native });
-        results.operations.push({ ...operation, applied: true, appendedRcBlock,
+        results.operations.push({ ...operation, applied: true,
           needsAction: outcome.needsAction ?? [],
           changes: outcome.changes ?? [], diagnostics: [
             ...(operation.deliveryDiagnostic === undefined
@@ -118,6 +119,19 @@ export async function applyPlan({ plan, adapters, context, dataHome, dryRun = fa
       results.failed.push({ adapterId: operation.adapterId, error: error.message });
     }
   }
+  // The eligibility cache a 0.7.x `claude` shim read before every launch. No
+  // shim reads it any more, and it holds nothing a user wrote.
+  if (!dryRun && typeof dataHome === "string") {
+    await rm(path.join(dataHome, "acc", "native-bootstrap"), { recursive: true, force: true })
+      .catch(() => {});
+    // A 0.7.x Claude Channel unlinked its own registration on a clean exit;
+    // one that crashed left it in its workspace, naming a dead socket.
+    const workspaces = path.join(dataHome, "acc", "workspaces");
+    for (const workspace of await readdir(workspaces).catch(() => [])) {
+      await rm(path.join(workspaces, workspace, "native", "claude"), { recursive: true, force: true })
+        .catch(() => {});
+    }
+  }
   return results;
 }
 

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

@@ -2,9 +2,7 @@
 // reasons; installation and doctor must not turn a version floor into readiness.
 const REASONS = Object.freeze({
   native_delivery_unsupported: "this adapter has no native delivery channel",
-  platform_not_captured: "native delivery is not verified on this platform",
   version_unavailable: "the client version could not be verified",
-  prerelease_not_captured: "this client version is not a verified stable release",
   below_minimum_version: "the client is below the native delivery minimum version",
   known_bad_version: "this client version has a known native delivery failure",
   native_endpoint_unavailable: "the client's local delivery service is unavailable",

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

@@ -5,7 +5,7 @@ import { capabilityEvidence, effectiveCapabilities, evaluateNativeEligibility,
   validateNativeActivationPlan }
   from "@agents-can-communicate/adapter-sdk";
 
-import { resolveExecutable, shellOf, shimDirFor } from "./native-activation.mjs";
+import { resolveExecutable, shimDirFor } from "./native-activation.mjs";
 
 import { describeDeliveryFallback, describeNativeReason } from "./delivery-diagnostics.mjs";
 
@@ -13,9 +13,8 @@ const run = promisify(execFile);
 
 // Reasons the client itself will not change within an install: unsupported,
 // as opposed to degraded, which a repaired probe or shell may lift.
-const STATIC_REASONS = new Set(["native_delivery_unsupported", "platform_not_captured",
-  "version_unavailable", "prerelease_not_captured", "below_minimum_version",
-  "known_bad_version"]);
+const STATIC_REASONS = new Set(["native_delivery_unsupported", "version_unavailable",
+  "below_minimum_version", "known_bad_version"]);
 
 const DEFAULT_PROBE_TIMEOUT_MS = 3_000;
 
@@ -76,15 +75,14 @@ async function detectNative(adapter, entry, { context, platform, probeTimeoutMs,
     }
     try {
       facts.eligibility = evaluateNativeEligibility(adapter,
-        { clientVersion: entry.version, platform, probe: facts.probe });
+        { clientVersion: entry.version, probe: facts.probe });
     } catch {
       facts.eligibility = { eligible: false, reasonCode: "feature_probe_failed" };
     }
     if (facts.eligibility.eligible !== true) {
       const reasonCode = facts.eligibility.reasonCode ?? "feature_probe_failed";
       // A stored policy can be consented to before a service/session exists.
-      // No activation is planned until the full probe passes; bootstrap-based
-      // clients still need their verified plan to disclose launch changes.
+      // No activation is planned until the full probe passes.
       const consentAvailable = adapter.nativeDelivery.policySource === "installation-record"
         && ["native_endpoint_unavailable", "native_session_unavailable"].includes(reasonCode);
       return STATIC_REASONS.has(reasonCode)
@@ -100,10 +98,6 @@ async function detectNative(adapter, entry, { context, platform, probeTimeoutMs,
       return degraded("feature_probe_failed", facts);
     }
     if (!activationPlan.eligible) return degraded(activationPlan.reasonCode, facts);
-    const shell = context?.shell ?? null;
-    if (activationPlan.mechanisms.some(item => item.kind === "shell-bootstrap") && shell !== "zsh") {
-      return { ...degraded("unsupported_shell", facts), activationPlan };
-    }
     return { state: "eligible", reasonCode: null, ...facts, activationPlan };
   } catch {
     return degraded("feature_probe_failed", { realExecutable: null, probe: null, eligibility: null });
@@ -165,6 +159,7 @@ export async function detectInstallation({ adapters, context, probe = spawnProbe
         // on the machine down with it.
         if (detected.blocked) entry.blocked = detected.blocked;
         if (detected.outgoingDelivery) entry.outgoingDelivery = detected.outgoingDelivery;
+        if (detected.inboundDelivery) entry.inboundDelivery = detected.inboundDelivery;
         if (detected.nativeSetup) entry.nativeSetup = detected.nativeSetup;
         entry.diagnostics = [...(detected.diagnostics ?? [])];
         // What a person has to do, as opposed to what is true. Adapters that

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

@@ -5,13 +5,10 @@ export { applyPlan } from "./apply.mjs";
 export { finalizeRemoval, fingerprint, loadOwnership, missingArtifactParents, recordInstall,
   removeEmptyOwnedDirectories, removeOwned, removeOwnedArtifacts, treeFingerprint, verifyOwned }
   from "./ownership.mjs";
-export { BOOTSTRAP_CACHE_SCHEMA, FAILED_TTL_MS, SUPPORTED_TTL_MS, cachePathFor,
-  checkNativeBootstrap } from "./bootstrap-runtime.mjs";
-export { BLOCK_BEGIN, BLOCK_END, SHIM_MARKER, SHIM_POLICIES, SUPPORTED_SHELLS,
-  installShellBootstrap, locateBlock, planShellBootstrap, renderCommandShim, renderPathBlock,
-  shellLiteral, uninstallShellBootstrap, validateShimEntry } from "./shell-bootstrap.mjs";
-export { LIVE_POLICIES, describeActivation, describeDeactivation, livePolicyOf, rcFileFor,
-  resolveExecutable, shellOf, shimDirFor } from "./native-activation.mjs";
+export { BLOCK_BEGIN, BLOCK_END, SHIM_MARKER, locateBlock, uninstallShellBootstrap }
+  from "./shell-bootstrap.mjs";
+export { LIVE_POLICIES, describeActivation, describeDeactivation, livePolicyOf,
+  resolveExecutable, shimDirFor } from "./native-activation.mjs";
 export { readInstalledLivePolicy, readInstalledLivePolicyState } from "./live-policy.mjs";
 export { describeDeliveryFallback, describeInstallDelivery, describeNativeReason }
   from "./delivery-diagnostics.mjs";

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

@@ -2,10 +2,7 @@ import { execFile } from "node:child_process";
 import { access, constants } from "node:fs/promises";
 import path from "node:path";
 
-import { defaultBootstrap } from "@agents-can-communicate/adapter-sdk";
-
-import { installShellBootstrap, planShellBootstrap, uninstallShellBootstrap }
-  from "./shell-bootstrap.mjs";
+import { uninstallShellBootstrap } from "./shell-bootstrap.mjs";
 import { LIVE_POLICIES, livePolicyOf } from "./live-policy.mjs";
 
 // The installer's side of a native activation: which owned mechanisms an
@@ -16,26 +13,15 @@ import { LIVE_POLICIES, livePolicyOf } from "./live-policy.mjs";
 // apply, and only when it did not already exist.
 
 export { LIVE_POLICIES, livePolicyOf };
-const MECHANISM_ORDER = ["native-config", "native-service", "shell-bootstrap"];
+const MECHANISM_ORDER = ["native-config", "native-service"];
 const SERVICE_TIMEOUT_MS = 15_000;
 
-export const shellOf = env => {
-  const shell = env?.SHELL;
-  return typeof shell === "string" && shell !== "" ? path.basename(shell) : null;
-};
+// Where ACC 0.7.x put its `claude` shim. An edited shim is kept rather than
+// deleted, so detection still has to look past this directory.
 export const shimDirFor = stateRoot => path.join(stateRoot, "bin");
-// `.zshrc`, deliberately, and that makes the shim interactive-only: zsh reads
-// this file for interactive shells and not for `zsh -lc` or a script. An
-// interactive launch is where a client session comes from, and putting the PATH
-// entry somewhere every shell reads would put ACC in front of a vendor command
-// in scripts and CI that never asked for it. Worth knowing when checking an
-// install: a non-interactive shell resolving the vendor binary directly is this
-// choice working, not a broken bootstrap.
-export const rcFileFor = (home, shell) => (shell === "zsh" && typeof home === "string"
-  ? path.join(home, ".zshrc") : null);
 
-// The vendor executable a shim will exec: the first executable on PATH that is
-// not ACC's own shim directory, so a shim never resolves itself.
+// The vendor executable to probe: the first executable on PATH outside the
+// excluded directories, so a kept 0.7.x shim is never probed as the client.
 export async function resolveExecutable(command, { pathEnv = "", exclude = [] } = {}) {
   const excluded = exclude.filter(Boolean).map(directory => path.resolve(directory));
   for (const directory of String(pathEnv).split(path.delimiter).filter(Boolean)) {
@@ -65,11 +51,7 @@ const renderCommand = command => [command.executable, ...command.args].join(" ")
 export function describeActivation(activation) {
   const lines = [];
   for (const mechanism of ordered(activation.mechanisms)) {
-    if (mechanism.kind === "shell-bootstrap") {
-      lines.push(`create shim ${path.join(activation.shimDir, mechanism.command)} for `
-        + `${mechanism.command} (${activation.livePolicy} live delivery)`);
-      lines.push(`add a PATH block to ${activation.rcFile}`);
-    } else if (mechanism.kind === "native-config") {
+    if (mechanism.kind === "native-config") {
       lines.push(`write native config ${mechanism.artifactIds.join(", ")}`);
     } else if (mechanism.preExisting) {
       lines.push(`use the existing ${mechanism.serviceId} service`);
@@ -96,47 +78,27 @@ export function describeDeactivation(nativeActivation) {
   return lines;
 }
 
-export async function applyNativeActivation({ adapter, activation, dataHome,
-  node = process.execPath, bootstrap = defaultBootstrap(), exec = defaultExec }) {
+export async function applyNativeActivation({ activation, exec = defaultExec }) {
   const record = { livePolicy: activation.livePolicy,
     protocolContract: activation.protocolContract, mechanisms: [] };
-  let shell = null;
-  try {
-    for (const mechanism of ordered(activation.mechanisms)) {
-      if (mechanism.kind === "native-config") {
-        record.mechanisms.push({ kind: mechanism.kind, artifactIds: [...mechanism.artifactIds] });
-      } else if (mechanism.kind === "native-service") {
-        let createdByAcc = false;
-        if (!mechanism.preExisting && mechanism.applyCommand !== null) {
-          await exec(mechanism.applyCommand.executable, mechanism.applyCommand.args);
-          createdByAcc = true;
-        }
-        record.mechanisms.push({ kind: mechanism.kind, serviceId: mechanism.serviceId,
-          createdByAcc, teardownCommand: mechanism.teardownCommand });
-      } else {
-        const plan = planShellBootstrap({ shell: activation.shell, rcFile: activation.rcFile,
-          shimDir: activation.shimDir, runtime: { node, bootstrap, dataHome },
-          entries: [{ adapterId: adapter.id, command: mechanism.command,
-            realExecutable: mechanism.realExecutable, prefixArgs: mechanism.prefixArgs,
-            livePolicy: activation.livePolicy }] });
-        const result = await installShellBootstrap({ plan });
-        if (!result.ok) throw new Error(`shell bootstrap refused: ${result.reasonCode}`);
-        shell = result;
-        record.mechanisms.push({ kind: mechanism.kind, command: mechanism.command, shimDir: activation.shimDir,
-          ownedFiles: result.shims.map(shim => ({ path: shim.path, sha256: shim.sha256 })),
-          rcFile: result.rcFile });
+  for (const mechanism of ordered(activation.mechanisms)) {
+    if (mechanism.kind === "native-config") {
+      record.mechanisms.push({ kind: mechanism.kind, artifactIds: [...mechanism.artifactIds] });
+    } else if (mechanism.kind === "native-service") {
+      let createdByAcc = false;
+      if (!mechanism.preExisting && mechanism.applyCommand !== null) {
+        await exec(mechanism.applyCommand.executable, mechanism.applyCommand.args);
+        createdByAcc = true;
       }
+      record.mechanisms.push({ kind: mechanism.kind, serviceId: mechanism.serviceId,
+        createdByAcc, teardownCommand: mechanism.teardownCommand });
+    } else {
+      // validateNativeActivationPlan refuses a shell bootstrap before any plan
+      // gets here; this is the same refusal for a hand-built one.
+      throw new Error("shell-bootstrap activation was removed");
     }
-    return { nativeActivation: record, appendedRcBlock: shell?.rcFile.appended === true };
-  } catch (error) {
-    // Only bytes this operation wrote are taken back; a pre-existing service
-    // or a user's own file is never touched on the way out.
-    if (shell !== null) {
-      await uninstallShellBootstrap({ ownership: { shims: shell.shims, shimDir: activation.shimDir,
-        rcFile: shell.rcFile } }).catch(() => null);
-    }
-    throw error;
   }
+  return { nativeActivation: record };
 }
 
 // Compare planned mechanisms with the deletion authority saved by older installs.

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

@@ -28,6 +28,8 @@ export async function fingerprint(file) {
   }
 }
 
+const CLIENT_ORPHAN_MARKER = ".orphaned_at";
+
 /**
  * Fingerprint of a whole directory ACC created.
  *
@@ -45,7 +47,11 @@ export async function treeFingerprint(root) {
     if (error.code === "ENOTDIR") return fingerprint(root);
     throw error;
   }
-  const files = entries.filter(entry => entry.isFile())
+  // Claude Code marks a plugin cache version its registry no longer names with
+  // `.orphaned_at`, and removes the marker again if the version comes back. That
+  // is the client's own bookkeeping inside a copy ACC keeps on purpose, never an
+  // edit, and ACC never writes a file by that name.
+  const files = entries.filter(entry => entry.isFile() && entry.name !== CLIENT_ORPHAN_MARKER)
     .map(entry => path.relative(root, path.join(entry.parentPath ?? entry.path, entry.name)))
     .sort();
   const hash = createHash("sha256");

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.1",
+  "version": "0.8.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.7.1",
+  "version": "0.8.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.7.1",
+  "version": "0.8.1",
   "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) {