agents-can-communicate 0.7.1 → 0.8.1

package/node_modules/@agents-can-communicate/adapter-sdk/src/native-delivery.mjs

@@ -1,73 +1,93 @@
-import { CONTRACT_ID, FINGERPRINT, HANDSHAKE_KEYS, KNOWN_BAD_REASON, NATIVE_ACTIVATION_KINDS,
-  NATIVE_BINDING_MODES, NATIVE_PLATFORMS, PROBE_KEYS, TIMESTAMP, assertModes,
-  assertReasonCode, closed, compareStableVersions, deepFreeze, isPlainObject, isText,
-  parseStableVersion, usage } from "./native-vocabulary.mjs";
+import { CONTRACT_ID, FINGERPRINT, HANDSHAKE_KEYS, KNOWN_BAD_REASON, NATIVE_BINDING_MODES,
+  PLANNABLE_ACTIVATION_KINDS, PROBE_KEYS, TIMESTAMP, assertModes, assertReasonCode, closed,
+  compareStableVersions, deepFreeze, isPlainObject, isText, parseStableVersion, usage }
+  from "./native-vocabulary.mjs";
+import { compareVersionOrder, versionOrder } from "./certification.mjs";
 
-// The native-delivery compatibility contract: a per-platform minimum that is a
-// real passing capture, one or more anchors naming the captured protocol, an
-// explicit denylist, and the activation kinds an adapter may ask the installer
-// for. There is deliberately no maximum: a newer stable client is admitted only
+// The native-delivery compatibility contract: a minimum that is a real passing
+// capture, one or more anchors naming the captured protocol, an explicit
+// denylist, and the activation kinds an adapter may ask the installer for.
+// There is deliberately no maximum: a newer stable client is admitted only
 // when a current read-only probe and a per-session handshake confirm the same
-// protocol contract. Exact-version certification still governs every other
-// capability; this rule is used for native live delivery alone.
+// protocol contract. There is no platform either: a capture records where a
+// behaviour was observed, the minimum it establishes applies everywhere, and
+// the probe and handshake decide on the machine in hand (see
+// docs/design/2026-09-26-native-delivery-across-platforms.md). Certification
+// evidence still governs every other capability; this rule is used for native
+// live delivery alone.
 
-export { NATIVE_ACTIVATION_KINDS, NATIVE_BINDING_MODES, NATIVE_PLATFORMS, NATIVE_REASON_CODES,
-  compareStableVersions, parseStableVersion } from "./native-vocabulary.mjs";
+export { NATIVE_ACTIVATION_KINDS, NATIVE_BINDING_MODES, NATIVE_REASON_CODES,
+  PLANNABLE_ACTIVATION_KINDS, compareStableVersions, parseStableVersion } from "./native-vocabulary.mjs";
 export { validateNativeActivationPlan } from "./native-activation.mjs";
 
 const orderedModes = modes => NATIVE_BINDING_MODES.filter(mode => modes.includes(mode));
 
 export function validateNativeDeliveryContract(value, { certification, client }) {
+  // Consent to live delivery is what `acc install` recorded. Up to 0.7.x a
+  // Claude shell shim could export it instead ("bootstrap-environment"); the
+  // shim is gone, and the installation record is the one source left.
   const policySource = Object.hasOwn(value ?? {}, "policySource")
-    ? value.policySource : "bootstrap-environment";
-  closed({ ...value, policySource },
-    ["minimumByPlatform", "anchors", "knownBad", "activationKinds", "policySource"],
+    ? value.policySource : "installation-record";
+  // What a successful offer put in front of the model. "message" carries the
+  // body, so the router records the receipt as offered. "wake" carries only a
+  // notice that makes the client run a turn; the body reaches the model through
+  // the next-turn hook, which records the offer itself once its stdout carried
+  // the body. Recording a wake as offered would hide the body from that hook.
+  const offerKind = Object.hasOwn(value ?? {}, "offerKind") ? value.offerKind : "message";
+  // The per-platform shape 0.8.0 and earlier declared. Refused by name: an
+  // adapter built against that SDK should learn what replaced it, not fail on
+  // a generic unknown field.
+  if (Object.hasOwn(value ?? {}, "minimumByPlatform")) {
+    usage("nativeDelivery.minimumByPlatform is no longer declared; a capture's minimum applies on "
+      + "every platform, so declare nativeDelivery.minimum instead "
+      + "(docs/design/2026-09-26-native-delivery-across-platforms.md)");
+  }
+  closed({ ...value, policySource, offerKind },
+    ["minimum", "anchors", "knownBad", "activationKinds", "policySource", "offerKind"],
     "nativeDelivery");
-  if (!["installation-record", "bootstrap-environment"].includes(policySource)) {
-    usage("nativeDelivery.policySource must be installation-record or bootstrap-environment");
+  if (policySource !== "installation-record") {
+    usage("nativeDelivery.policySource must be installation-record");
   }
-  const minimums = value.minimumByPlatform;
-  if (!isPlainObject(minimums) || Object.keys(minimums).length === 0) {
-    usage("nativeDelivery.minimumByPlatform must map at least one captured platform to a version");
+  if (!["message", "wake"].includes(offerKind)) {
+    usage("nativeDelivery.offerKind must be message or wake");
   }
-  for (const [platform, version] of Object.entries(minimums)) {
-    if (!NATIVE_PLATFORMS.includes(platform)) {
-      usage(`nativeDelivery.minimumByPlatform names an unknown platform ${platform}`);
-    }
-    if (parseStableVersion(version) === null) {
-      usage(`nativeDelivery.minimumByPlatform ${platform} must be a stable version`);
-    }
+  const minimum = value.minimum;
+  if (parseStableVersion(minimum) === null) {
+    usage("nativeDelivery.minimum must be a stable version");
   }
   if (!Array.isArray(value.anchors) || value.anchors.length === 0) {
     usage("nativeDelivery.anchors must name at least one passing capture");
   }
   const anchors = value.anchors.map((anchor, index) => {
-    closed(anchor, ["platform", "version", "protocolContract"], "nativeDelivery anchor");
-    const minimum = minimums[anchor.platform];
-    if (minimum === undefined) {
-      usage(`nativeDelivery anchor ${index} platform ${anchor.platform} has no minimum`);
+    if (Object.hasOwn(anchor ?? {}, "platform")) {
+      usage(`nativeDelivery anchor ${index} names a platform; the platform a capture was taken on `
+        + "is recorded by its evidence, and the anchor names the version alone "
+        + "(docs/design/2026-09-26-native-delivery-across-platforms.md)");
     }
-    if (parseStableVersion(anchor.version) === null
-      || compareStableVersions(anchor.version, minimum) < 0) {
-      usage(`nativeDelivery anchor ${index} version must be a stable version at or above the minimum`);
+    closed(anchor, ["version", "protocolContract"], "nativeDelivery anchor");
+    if (parseStableVersion(anchor.version) === null) {
+      usage(`nativeDelivery anchor ${index} version must be a stable version`);
+    }
+    if (compareStableVersions(anchor.version, minimum) < 0) {
+      usage(`nativeDelivery anchor ${index} version ${anchor.version} is below the minimum ${minimum}: `
+        + "the minimum must be the first passing capture");
     }
     if (!isText(anchor.protocolContract) || !CONTRACT_ID.test(anchor.protocolContract)) {
       usage(`nativeDelivery anchor ${index} protocolContract must be a closed identifier`);
     }
+    // Where the capture was taken is provenance the evidence row keeps; the
+    // anchor is proven by a passing capture of this version on any platform.
     const proven = (certification?.evidence ?? []).some(item => item.result === "pass"
       && item.capability === "delivery.livePush" && item.client === client
-      && item.version === anchor.version && item.platform === anchor.platform);
+      && item.version === anchor.version);
     if (!proven) {
-      usage(`nativeDelivery anchor ${anchor.version} on ${anchor.platform} has no passing `
-        + "delivery.livePush certification", { anchor });
+      usage(`nativeDelivery anchor ${anchor.version} has no passing delivery.livePush certification`,
+        { anchor });
     }
     return { ...anchor };
   });
-  for (const [platform, minimum] of Object.entries(minimums)) {
-    if (!anchors.some(anchor => anchor.platform === platform && anchor.version === minimum)) {
-      usage(`nativeDelivery minimum ${minimum} on ${platform} must be the first passing capture: `
-        + "no anchor matches it");
-    }
+  if (!anchors.some(anchor => compareStableVersions(anchor.version, minimum) === 0)) {
+    usage(`nativeDelivery minimum ${minimum} must be the first passing capture: no anchor matches it`);
   }
   if (!Array.isArray(value.knownBad)) usage("nativeDelivery.knownBad must be an array");
   const knownBad = value.knownBad.map(entry => {
@@ -89,27 +109,32 @@ export function validateNativeDeliveryContract(value, { certification, client })
   });
   const kinds = value.activationKinds;
   if (!Array.isArray(kinds) || kinds.length === 0 || new Set(kinds).size !== kinds.length
-    || kinds.some(kind => !NATIVE_ACTIVATION_KINDS.includes(kind))) {
-    usage(`nativeDelivery.activationKinds must be unique entries of ${NATIVE_ACTIVATION_KINDS.join(", ")}`);
+    || kinds.some(kind => !PLANNABLE_ACTIVATION_KINDS.includes(kind))) {
+    usage(`nativeDelivery.activationKinds must be unique entries of ${PLANNABLE_ACTIVATION_KINDS.join(", ")}`);
   }
-  return deepFreeze({ minimumByPlatform: { ...minimums }, anchors, knownBad,
-    activationKinds: [...kinds], policySource });
+  return deepFreeze({ minimum, anchors, knownBad, activationKinds: [...kinds], policySource,
+    offerKind });
 }
 
-function knownBadHit(contract, version) {
+// `order` is the client's release triple; the denylist names stable versions,
+// so a prerelease of a denylisted release is on it too.
+function knownBadHit(contract, order) {
+  const hit = (left, right) => compareVersionOrder(left, versionOrder(right));
   return contract.knownBad.some(entry => (Object.hasOwn(entry, "version")
-    ? compareStableVersions(version, entry.version) === 0
-    : compareStableVersions(version, entry.from) >= 0 && compareStableVersions(version, entry.to) <= 0));
+    ? hit(order, entry.version) === 0
+    : hit(order, entry.from) >= 0 && hit(order, entry.to) <= 0));
 }
 
 // Judges one reported client version against an adapter's captured
-// native-delivery contract: is the platform captured, is the version at or
-// above the captured minimum, and is it not on the denylist. Returns
+// native-delivery contract: is the version at or above the captured minimum,
+// and is it not on the denylist. Returns
 // { reasonCode, minimumVersion, protocolContract }; reasonCode is null when
 // the version satisfies the contract, otherwise one of
-// "native_delivery_unsupported", "platform_not_captured",
-// "version_unavailable", "prerelease_not_captured", "below_minimum_version",
-// or "known_bad_version".
+// "native_delivery_unsupported", "version_unavailable", "below_minimum_version",
+// or "known_bad_version". The platform the caller runs on plays no part: the
+// minimum was captured somewhere and applies everywhere. A prerelease is
+// judged by its release triple, as hook capabilities are: what admits it is
+// the protocol contract the probe or handshake reports, not the suffix.
 //
 // This is the static half of the rule only: it never contacts the client, so
 // passing here proves nothing about whether a live probe or handshake
@@ -118,38 +143,33 @@ function knownBadHit(contract, version) {
 // validateNativeHandshake below, and the delivery router's own offer check,
 // which uses this function alone because a response already carries no probe
 // or handshake shape to check further).
-export function evaluateVersionContract(adapter, { clientVersion, platform }) {
+export function evaluateVersionContract(adapter, { clientVersion } = {}) {
   const contract = adapter?.nativeDelivery;
-  // `== null` rather than `=== undefined`: a null declaration is as much "no
-  // contract" as a missing one, and reading `contract.minimumByPlatform` off it
-  // threw the very TypeError the guard below exists to prevent. defineAdapter
-  // cannot produce that shape; a hand-built registry entry can.
-  if (contract == null) {
-    return { reasonCode: "native_delivery_unsupported", minimumVersion: null, protocolContract: null };
-  }
-  const uncaptured = { reasonCode: "platform_not_captured", minimumVersion: null,
+  const unsupported = { reasonCode: "native_delivery_unsupported", minimumVersion: null,
     protocolContract: null };
-  // validateNativeDeliveryContract guarantees a minimum map and a matching
-  // anchor, but this function is also handed adapter objects that never went
-  // through it. A declaration missing either half has captured nothing for
-  // this platform, which is a closed answer - not a TypeError raised deep
-  // inside a delivery offer, far from the declaration that caused it. Every
-  // other entry point below already answers malformed input this way.
-  if (typeof platform !== "string" || !isPlainObject(contract.minimumByPlatform)) return uncaptured;
-  const minimumVersion = contract.minimumByPlatform[platform] ?? null;
-  if (minimumVersion === null) return uncaptured;
+  // `== null` rather than `=== undefined`: a null declaration is as much "no
+  // contract" as a missing one, and reading `contract.minimum` off it threw
+  // the very TypeError the guard below exists to prevent. defineAdapter cannot
+  // produce that shape; a hand-built registry entry can.
+  if (contract == null) return unsupported;
+  // validateNativeDeliveryContract guarantees a minimum and a matching anchor,
+  // but this function is also handed adapter objects that never went through
+  // it. A declaration missing either half has captured nothing, which is a
+  // closed answer - not a TypeError raised deep inside a delivery offer, far
+  // from the declaration that caused it. Every other entry point below
+  // already answers malformed input this way.
+  const minimumVersion = isText(contract.minimum) ? contract.minimum : null;
+  if (minimumVersion === null) return unsupported;
   const anchor = (Array.isArray(contract.anchors) ? contract.anchors : [])
-    .find(item => item.platform === platform && item.version === minimumVersion);
-  if (anchor === undefined) return uncaptured;
+    .find(item => item?.version === minimumVersion);
+  if (anchor === undefined) return unsupported;
   const facts = { minimumVersion, protocolContract: anchor.protocolContract };
-  if (!isText(clientVersion)) return { ...facts, reasonCode: "version_unavailable" };
-  if (parseStableVersion(clientVersion) === null) {
-    return { ...facts, reasonCode: "prerelease_not_captured" };
-  }
-  if (compareStableVersions(clientVersion, minimumVersion) < 0) {
+  const order = versionOrder(clientVersion);
+  if (order === null) return { ...facts, reasonCode: "version_unavailable" };
+  if (compareVersionOrder(order, versionOrder(minimumVersion)) < 0) {
     return { ...facts, reasonCode: "below_minimum_version" };
   }
-  if (knownBadHit(contract, clientVersion)) return { ...facts, reasonCode: "known_bad_version" };
+  if (knownBadHit(contract, order)) return { ...facts, reasonCode: "known_bad_version" };
   return { ...facts, reasonCode: null };
 }
 
@@ -172,13 +192,13 @@ function validateNativeProbe(probe) {
   return probe;
 }
 
-export function evaluateNativeEligibility(adapter, { clientVersion, platform, probe }) {
+export function evaluateNativeEligibility(adapter, { clientVersion, probe }) {
   // The probe names the process that will serve the delivery. Judging the
   // detected binary instead refuses a service that satisfies the contract.
   // Only the version is read here; the shape is validated where it always was,
   // so a malformed probe still returns a closed result rather than throwing.
   const serving = isText(probe?.clientVersion) ? probe.clientVersion : clientVersion;
-  const rule = evaluateVersionContract(adapter, { clientVersion: serving, platform });
+  const rule = evaluateVersionContract(adapter, { clientVersion: serving });
   const base = { eligible: false, reasonCode: null, minimumVersion: rule.minimumVersion,
     protocolContract: rule.protocolContract, modes: [] };
   const closedResult = reasonCode => deepFreeze({ ...base, reasonCode });
@@ -230,13 +250,13 @@ function validateNativeHandshakeShape(handshake) {
 // the two records disagreed on every machine where a daemon had updated under
 // its CLI, which is exactly the case the release exists to support. A refused
 // verdict admits nothing and carries null.
-export function validateNativeHandshake(adapter, { clientVersion, platform, handshake }) {
+export function validateNativeHandshake(adapter, { clientVersion, handshake }) {
   // Same rationale as the probe: the handshake names the session that will
   // actually serve, so the static rule is judged against that version. Only
   // the version is read here; the shape is validated where it always was, so
   // a malformed handshake still returns a closed result rather than throwing.
   const serving = isText(handshake?.clientVersion) ? handshake.clientVersion : clientVersion;
-  const rule = evaluateVersionContract(adapter, { clientVersion: serving, platform });
+  const rule = evaluateVersionContract(adapter, { clientVersion: serving });
   const base = { ok: false, reasonCode: null, clientVersion: null,
     protocolContract: rule.protocolContract, modes: [],
     opaqueEndpointRef: null, leaseUntil: null };

package/node_modules/@agents-can-communicate/adapter-sdk/src/native-vocabulary.mjs

@@ -9,16 +9,21 @@ export const NATIVE_BINDING_MODES = Object.freeze([
   "livePush", "idleWake", "busyQueue", "replyRoute",
 ]);
 
+// Every kind an install record may carry. "shell-bootstrap" is the `claude`
+// shim ACC 0.7.x wrote; records of it stay readable so it can be retired.
 export const NATIVE_ACTIVATION_KINDS = Object.freeze([
   "shell-bootstrap", "native-config", "native-service",
 ]);
 
-export const NATIVE_PLATFORMS = Object.freeze([
-  "darwin-arm64", "darwin-x64", "linux-arm64", "linux-x64", "win32-x64",
-]);
+// The kinds an adapter may still ask for.
+export const PLANNABLE_ACTIVATION_KINDS = Object.freeze(["native-config", "native-service"]);
 
 // Every reason a client is not live, closed so doctor, hooks, and docs share
 // one vocabulary and vendor strings never leak through it.
+// "platform_not_captured" and "prerelease_not_captured" are historical: 0.8.0
+// and earlier refused a platform no capture named and any prerelease suffix,
+// and their native-attempt records carry both. Nothing produces either any
+// more (docs/design/2026-09-26-native-delivery-across-platforms.md).
 export const NATIVE_REASON_CODES = Object.freeze([
   "native_delivery_unsupported", "platform_not_captured", "version_unavailable",
   "prerelease_not_captured", "below_minimum_version", "known_bad_version",
@@ -34,7 +39,6 @@ export const NATIVE_REASON_CODES = Object.freeze([
 export const STABLE_VERSION = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:\+[0-9A-Za-z.-]+)?$/;
 export const CONTRACT_ID = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/;
 export const IDENTIFIER = /^[a-z][a-z0-9_-]*$/;
-export const COMMAND_NAME = /^[a-z][a-z0-9_.-]*$/;
 export const FINGERPRINT = /^sha256:[0-9a-f]{64}$/;
 export const TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,3})?Z$/;
 export const SHELL_SOURCE = /[;&|<>`\n\0]|\$\(/;

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

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

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

@@ -2,7 +2,7 @@ import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";
 
-import { describeDeliveryFallback, detectInstallation, livePolicyOf, loadOwnership, shellOf, verifyOwned }
+import { describeDeliveryFallback, detectInstallation, livePolicyOf, loadOwnership, verifyOwned }
   from "@agents-can-communicate/installer";
 import { AccError, EXIT } from "@agents-can-communicate/protocol";
 
@@ -114,12 +114,9 @@ export async function diagnoseAdapters({ options, runtime, detect = detectInstal
   const home = options?.home ?? runtime?.env?.HOME ?? homedir();
   const { data: dataHome } = platformPaths({ platform: runtime?.platform,
     env: runtime?.env ?? {} });
-  // The same shell and environment install reads, so detection plans the same
-  // shell bootstrap it would apply. Omitting them left detection with a null
-  // shell, which degrades every shell-bootstrap client to `unsupported_shell` -
-  // so a zsh machine with a working shim read as degraded on every run.
+  // The same environment install reads, so detection probes the same client.
   const clients = clientContext(home, path.join(dataHome, "acc"),
-    { shell: shellOf(runtime?.env ?? {}), env: runtime?.env ?? {} });
+    { env: runtime?.env ?? {} });
   const adapters = ALL_ADAPTERS();
   const detected = await detect({ adapters, context: clients,
     probeTimeoutMs: probeTimeout(runtime?.env) });
@@ -297,6 +294,11 @@ export async function runDoctor({ options, context, runtime }) {
   ...nativeSessionLines(adapters),
   ...adapters.filter(adapter => adapter.present && adapter.outgoingDelivery?.state === "configured")
     .map(adapter => `  ${adapter.displayName} ${adapter.outgoingDelivery.diagnostic}`),
+  // The client's own inbound control decides whether a wake reaches the model.
+  // Only someone who turned live delivery on needs to hear about it.
+  ...adapters.filter(adapter => adapter.present && adapter.nativeDelivery.configured
+    && typeof adapter.inboundDelivery?.diagnostic === "string")
+    .map(adapter => `  ${adapter.displayName} inbound: ${adapter.inboundDelivery.diagnostic}`),
   ...(manager === null ? [] : [`  automatic updates ${manager.auto ? "on" : "off"}; ACC ${manager.active.version}`
     + (manager.pin ? `; pinned to ${manager.pin}` : ""), ...(update.notice ? [`  ${update.notice}`] : [])]),
   ...data.remediation.map(line => `  ${line}`),

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

@@ -7,8 +7,7 @@ import { createCodexAdapter } from "@agents-can-communicate/adapter-codex";
 import { createGeminiCliAdapter } from "@agents-can-communicate/adapter-gemini-cli";
 import { createGrokAdapter } from "@agents-can-communicate/adapter-grok";
 import { createKimiAdapter } from "@agents-can-communicate/adapter-kimi";
-import { applyPlan, detectInstallation,
-  loadOwnership, planInstallation, rcFileFor, shellOf, shimDirFor }
+import { applyPlan, detectInstallation, loadOwnership, planInstallation }
   from "@agents-can-communicate/installer";
 import { AccError, EXIT } from "@agents-can-communicate/protocol";
 
@@ -29,7 +28,7 @@ export { decideDelivery } from "./install-delivery-consent.mjs";
 // pointed at the home itself writes beside them rather than inside them. That
 // install reports success and the client never reads a byte of it.
 export const clientContext = (home, stateRoot,
-  { shell = null, env = {}, dataHome, cwd = process.cwd() } = {}) => ({
+  { env = {}, dataHome, cwd = process.cwd() } = {}) => ({
   home,
   ...(dataHome === undefined ? {} : { dataHome }),
   configDir: path.join(home, ".claude"),
@@ -39,10 +38,8 @@ export const clientContext = (home, stateRoot,
   kimiHome: path.join(home, ".kimi-code"),
   grokHome: typeof env.GROK_HOME === "string" && env.GROK_HOME !== ""
     ? env.GROK_HOME : path.join(home, ".grok"),
-  // The user's login shell and PATH, for the optional native shell bootstrap:
-  // which rc file could carry an ACC PATH block and which real executable a
-  // shim would exec. Detection reads them; nothing here writes.
-  shell,
+  // The user's PATH, for finding the real client executable to probe.
+  // Detection reads it; nothing here writes.
   env,
   // Antigravity CLI keeps its hooks in the `~/.gemini` tree Gemini CLI also
   // uses, and reads none of the same files. Two locations load - the
@@ -200,8 +197,7 @@ export function describeOutcome({ action, acted, failed = [], skipped = [],
 export function failureOf({ action, acted, failed = [], operations = [], skipped = [], home }) {
   if (failed.length === 0) return null;
   return new AccError(EXIT.DATA,
-    [describeOutcome({ action, acted, failed, operations, skipped, home }),
-      ...reloadAdvice(operations)].join("\n"), { failed });
+    describeOutcome({ action, acted, failed, operations, skipped, home }), { failed });
 }
 
 /**
@@ -220,23 +216,13 @@ export function actedOn(result) {
         + (operation.changes?.length ?? 0) > 0)).length;
 }
 
-// Said once, after the first PATH block is written: a running shell and a
-// running client know nothing about it.
-function reloadAdvice(operations) {
-  const appended = operations.filter(operation => operation.appendedRcBlock === true);
-  if (appended.length === 0) return [];
-  const rc = appended[0].nativeActivation?.rcFile ?? "your shell rc file";
-  return ["", `native delivery is wired for new sessions: open a new terminal (or reload ${rc}), `
-    + "then start the client normally; a session already running keeps durable delivery"];
-}
-
 export async function runInstallCommand({ options, runtime, action = "install" }) {
   const adapters = selectAdapters(options.adapter);
   const home = options.home ?? runtime.env?.HOME ?? homedir();
   const { data: dataHome } = platformPaths({ platform: runtime.platform,
     env: runtime.env ?? {} });
   const context = clientContext(home, path.join(dataHome, "acc"),
-    { shell: shellOf(runtime.env), env: runtime.env ?? {}, dataHome });
+    { env: runtime.env ?? {}, dataHome });
 
   const detected = await detectInstallation({ adapters, context,
     probeTimeoutMs: probeTimeout(runtime.env) });
@@ -273,7 +259,7 @@ export async function runInstallCommand({ options, runtime, action = "install" }
     deliveryDecisionByAdapter: decided.deliveryDecisionByAdapter,
     allowServiceSetup: action === "install" });
   const apply = (paths = {}) => applyPlan({ plan, adapters, context: { ...context, ...paths },
-    dataHome, dryRun, accVersion, activation: { bootstrap: paths.bootstrap } });
+    dataHome, dryRun, accVersion });
   const result = action === "install" && !dryRun && runtime.packageRoot
     ? await installManaged({ packageRoot: runtime.packageRoot,
       managerRoot: path.join(dataHome, "acc", "runtime"), dataHome, home, cwd: options.cwd ?? runtime.cwd,
@@ -293,9 +279,8 @@ export async function runInstallCommand({ options, runtime, action = "install" }
 
   return { data: { ...result, plan, dataHome, deliveryByAdapter: decided.deliveryByAdapter,
     deliveryDecisionByAdapter: decided.deliveryDecisionByAdapter, asked: decided.asked },
-  text: [describeOutcome({ action, acted, failed: result.failed,
+  text: describeOutcome({ action, acted, failed: result.failed,
     skipped: plan.skipped, operations: result.operations, home }),
-  ...reloadAdvice(result.operations)].join("\n"),
   error: failureOf({ action, acted, failed: result.failed, operations: result.operations,
     skipped: plan.skipped, home }) };
 }

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

@@ -57,9 +57,6 @@ function questionFor(entries) {
   const names = entries.map(entry => entry.displayName ?? entry.adapterId).join(", ");
   const setup = [...new Set(entries.map(entry => entry.outgoingDelivery?.setup)
     .filter(value => typeof value === "string"))];
-  const channels = entries.some(entry => (entry.nativeDelivery?.activationPlan?.mechanisms ?? [])
-    .some(mechanism => mechanism.kind === "shell-bootstrap"
-      && (mechanism.prefixArgs ?? []).some(argument => argument.startsWith("--"))));
   return [
     `Complete automatic peer-request setup for ${names}? (experimental)`,
     "  Yes: automatic turns can spend tokens without waiting for you.",
@@ -69,7 +66,9 @@ function questionFor(entries) {
     ...entries.filter(needsPrerequisite).map(entry =>
       `       Download the official Codex ${entry.nativeServiceSetup.cliVersion} standalone package for its service; retain your existing codex command.`),
     ...setup.map(note => `       ${note}`),
-    ...(channels ? ["       Allow Claude Code development Channels when prompted at startup."] : []),
+    ...(entries.some(entry => entry.adapterId === "claude_code")
+      ? ["       Claude Code sessions that bypass permission prompts ask before each ACC wake;",
+        "       set Claude Code's crossSessionInbound to accept to take wakes without asking."] : []),
     "  No: keep current delivery policies and use available next-turn hooks or acc inbox.",
   ].join("\n");
 }

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

@@ -138,13 +138,26 @@ function obligationFor(kind, explicit, addressed) {
   return obligation;
 }
 
-function recordedText(message, delivery) {
+export function recordedText(message, delivery) {
   const diagnostics = delivery.map(item => item.outcome === "offered"
     ? `live offered to ${item.recipientParticipantId} via ${item.transport}`
+    : item.outcome === "woken" && item.pendingApproval === true
+      ? `sent a wake to ${item.recipientParticipantId} via ${item.transport}, which its session holds `
+        + "for approval because it bypasses permission prompts; the message arrives with its next turn"
+    : item.outcome === "woken"
+      ? `woke ${item.recipientParticipantId} via ${item.transport}; the message arrives with its next turn`
     : item.outcome === "queued"
       ? item.errorCode === "transport_permission_denied"
         ? "live offer blocked by sender permissions; message remains queued; run acc doctor in the sending session"
-        : `live offer unavailable (${item.errorCode ?? "durable_fallback"})`
+        : item.errorCode === "no_live_transport"
+          ? `${item.recipientParticipantId} has no live transport; the message waits in its inbox`
+        : item.errorCode === "recipient_offline" && item.endReason === "clear"
+          ? `${item.recipientParticipantId}'s conversation was cleared (/clear); the message waits `
+            + "until that conversation resumes"
+        : item.errorCode === "recipient_offline"
+          ? `${item.recipientParticipantId} has no open session; the message waits until it starts `
+            + "or resumes one"
+          : `live offer unavailable (${item.errorCode ?? "durable_fallback"})`
       : `delivery already ${item.outcome}`);
   return [`recorded ${message.messageId}`, ...diagnostics].join("; ");
 }
@@ -185,7 +198,15 @@ export function describeStatus(status) {
   // A transport accepting a message is not a model reading it. Said only when
   // it is true of something, so the everyday line stays the everyday line.
   const offered = status.counts.unretrieved?.offered ?? 0;
-  return offered === 0 ? line : `${line}; ${offered} offered, not retrieved`;
+  const withOffers = offered === 0 ? line : `${line}; ${offered} offered, not retrieved`;
+  // Status lists a participant with no open session only while messages wait
+  // for it; each is named here, with the client's reason when it gave one. The
+  // count is what its next turn would still show, never an offer already made.
+  const waiting = (status.participants ?? [])
+    .filter(item => item.presence === "offline" && (item.waiting ?? 0) > 0)
+    .map(item => `${item.participantId} (${item.endReason === "clear" ? "cleared, " : ""}${item.waiting})`);
+  return waiting.length === 0 ? withOffers
+    : `${withOffers}; waiting for a closed session: ${waiting.join(", ")}`;
 }
 
 const HANDLERS = Object.freeze({

package/node_modules/@agents-can-communicate/cli/src/managed-runtime/entry.mjs

@@ -7,24 +7,13 @@ import { canonicalManagerRoot, readControl, readManagedJson } from "./state.mjs"
 import { commandPrefix } from "./command-prefix.mjs";
 
 export const ENTRY_KINDS = Object.freeze([
-  "acc", "acc-hook", "acc-mcp", "acc-bootstrap", "acc-claude-channel", "acc-antigravity-relay",
+  "acc", "acc-hook", "acc-mcp", "acc-antigravity-relay",
 ]);
 
-const BOOTSTRAP_FLAGS = new Map([["--adapter", "adapter"], ["--real-executable", "realExecutable"],
-  ["--data-home", "dataHome"]]);
-
-/** Shared with the runtime; parse before admission without importing installer code. */
-export function parseBootstrapOptions(args) {
-  const options = {};
-  for (let index = 0; index < args.length; index += 2) {
-    const key = BOOTSTRAP_FLAGS.get(args[index]);
-    const value = args[index + 1];
-    if (key === undefined || typeof value !== "string" || value === "" || key in options) return null;
-    options[key] = value;
-  }
-  return BOOTSTRAP_FLAGS.values().every(key => key in options) && path.isAbsolute(options.dataHome)
-    ? options : null;
-}
+// Kinds a 0.7.x install wrote a launcher for. The package still ships their
+// entrypoints for 0.7.x updaters and launchers; a current install removes the
+// launchers themselves.
+export const RETIRED_ENTRY_KINDS = Object.freeze(["acc-bootstrap", "acc-claude-channel"]);
 
 // Bootstrap resolution deliberately needs only Node built-ins: no selected
 // generation is imported until admission and its actual PID lease are durable.
@@ -43,11 +32,9 @@ export function invokedDirectly(url) {
 
 function unavailable(kind) {
   // Never reflect control file content or payloads into a client diagnostic.
-  if (kind === "acc-hook" || kind === "acc-claude-channel" || kind === "acc-antigravity-relay") {
+  if (kind === "acc-hook" || kind === "acc-antigravity-relay") {
     process.stderr.write("acc: coordination unavailable during runtime update; session may continue\n");
     process.exitCode = 0;
-  } else if (kind === "acc-bootstrap") {
-    process.exitCode = 1; // The vendor shell shim launches its original command.
   } else {
     process.stderr.write("acc: runtime unavailable; retry after the update or run acc update to recover\n");
     process.exitCode = 4;
@@ -83,28 +70,12 @@ async function updateImplementation(packageRoot, control) {
 export async function runEntry({ kind, packageRoot, managerRoot, managedRequired = false }) {
   if (!ENTRY_KINDS.includes(kind)) throw new Error("unknown ACC entry point");
   const command = kind === "acc" ? commandPrefix(process.argv.slice(2)).command : null;
-  const bootstrapOptions = kind === "acc-bootstrap" ? parseBootstrapOptions(process.argv.slice(2)) : null;
-  if (kind === "acc-bootstrap" && bootstrapOptions === null) {
-    if (process.env.ACC_BOOTSTRAP_DEBUG === "1") {
-      process.stderr.write("acc-bootstrap: usage: --adapter <id> --real-executable <path> --data-home <path>\n");
-    }
-    process.exitCode = 2;
-    return;
-  }
   let selected = packageRoot;
   let managed = null;
   let managementOnly = false;
   let root;
   try {
-    const requestedDataHome = bootstrapOptions === null ? null : await canonicalManagerRoot(bootstrapOptions.dataHome);
-    const requestedRoot = requestedDataHome === null ? null
-      : await canonicalManagerRoot(path.join(requestedDataHome, "acc", "runtime"));
-    if (managerRoot && requestedDataHome !== null
-      && requestedDataHome !== await canonicalManagerRoot(path.dirname(path.dirname(managerRoot)))) {
-      throw new Error("bootstrap cache home differs from its launcher");
-    }
-    root = await canonicalManagerRoot(managerRoot ?? requestedRoot ?? managerLocation());
-    if (requestedRoot !== null && root !== requestedRoot) throw new Error("bootstrap data home differs from its launcher");
+    root = await canonicalManagerRoot(managerRoot ?? managerLocation());
     const control = await readControl(root);
     if (control !== null) {
       selected = control.active.root;
@@ -138,13 +109,6 @@ export async function runEntry({ kind, packageRoot, managerRoot, managedRequired
       } catch { /* Fall through to the same graceful unavailability below. */ }
     }
     unavailable(kind);
-    if (kind === "acc-claude-channel" && selected) {
-      try {
-        const { startInertChannel } = await import(pathToFileURL(path.join(selected,
-          "bin", "entrypoints", "claude-channel-stdio.mjs")).href);
-        startInertChannel();
-      } catch { /* The stderr notice above already fired either way. */ }
-    }
     return;
   }
   const runtime = await import(pathToFileURL(path.join(selected, "bin", "entrypoints", `${kind}.mjs`)).href);

package/node_modules/@agents-can-communicate/cli/src/managed-runtime/launchers.mjs

@@ -1,7 +1,7 @@
 import { createHash, randomUUID } from "node:crypto";
 import { lstat, mkdtemp, open, readFile, rename, rm } from "node:fs/promises";
 import path from "node:path";
-import { ENTRY_KINDS } from "./entry.mjs";
+import { ENTRY_KINDS, RETIRED_ENTRY_KINDS } from "./entry.mjs";
 import { managedDirectory, syncDirectory } from "./state.mjs";
 
 const MODULES = ["entry.mjs", "command-prefix.mjs", "state.mjs", "generation-files.mjs",
@@ -14,8 +14,6 @@ async function durableFile(file, bytes, mode = 0o600) {
 
 export const stablePaths = root => ({
   cli: path.join(root, "bin", "acc.mjs"), runner: path.join(root, "bin", "acc-hook.mjs"),
-  bootstrap: path.join(root, "bin", "acc-bootstrap.mjs"),
-  channel: path.join(root, "bin", "acc-claude-channel.mjs"),
   antigravityRelay: path.join(root, "bin", "acc-antigravity-relay.mjs"),
 });
 
@@ -57,6 +55,10 @@ export async function writeLaunchers(root, packageRoot) {
       await rename(temporary, path.join(bin, `${kind}.mjs`));
     } finally { await rm(temporary, { force: true }); }
   }
+  // A 0.7.x `claude` shim or plugin copy that still reaches for one of these
+  // finds nothing: the shim then launches the vendor command untouched, and a
+  // re-laid plugin names none of them.
+  for (const kind of RETIRED_ENTRY_KINDS) await rm(path.join(bin, `${kind}.mjs`), { force: true });
   await syncDirectory(bin);
   return stablePaths(root);
 }