agents-can-communicate 0.7.1 → 0.8.0

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.0",
   "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.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.1",
+  "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.1",
+  "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"]
-    }
-  }
-}