agents-can-communicate 0.7.1 → 0.8.0

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

@@ -7,13 +7,14 @@ import path from "node:path";
 import { AccError, EXIT } from "@agents-can-communicate/protocol";
 import { fileURLToPath } from "node:url";
 
-import { acccreatedFile, bakeSkillCommand, blankJson, defaultBootstrap, defaultChannel,
+import { acccreatedFile, bakeSkillCommand, blankJson,
   mergeOwnedEntries, ownedEntries,
   keepVersions, ownVersion, stampPluginVersion,
   removeIfEmpty,
   removeInstalledTree,
   removeOwnedEntries, writeCliShim, writeForeignJson, writeHookShim }
   from "@agents-can-communicate/adapter-sdk";
+import { MANAGED_SETTINGS, inboundStatus } from "./inbox-settings.mjs";
 
 const bundle = fileURLToPath(new URL("../plugin", import.meta.url));
 const manifest = fileURLToPath(new URL("../plugin/.claude-plugin/plugin.json",
@@ -22,9 +23,6 @@ const manifest = fileURLToPath(new URL("../plugin/.claude-plugin/plugin.json",
 const PLUGIN_NAME = "agents-can-communicate";
 const MARKETPLACE = "acc-local";
 const QUALIFIED = `${PLUGIN_NAME}@${MARKETPLACE}`;
-const CHANNEL_ACTIVATION_CHECK = "Check Claude's Channels startup notice for ACC; "
-  + "an MCP connection does not verify inbound delivery. If Channels are unavailable "
-  + "or blocked, resolve that client warning before expecting live messages.";
 
 /**
  * How this client actually installs a plugin.
@@ -147,24 +145,21 @@ const marketplaceManifest = () => ({
   }],
 });
 
-// The channel MCP entry Claude Code loads only when the session is started with
-// the captured development-channel flag. Written with the pinned Node and the
-// installed Channel binary, so the generated file carries no repository path;
-// removed entirely for a non-live install so a plain launch spawns nothing.
+// Up to 0.7.x a live install wrote the Channel MCP server here, and Claude
+// Code spawned it for every session that enabled the plugin. The inbox wake
+// needs no MCP server, so no plugin copy ACC keeps may name one.
 const mcpPath = target => path.join(target, ".mcp.json");
-async function writeChannelMcp(target, { node, channel }) {
-  await writeJson(mcpPath(target), { mcpServers: { "acc-channel": {
-    command: node, args: [channel] } } });
+
+async function removeChannelConfig(versionsRoot) {
+  const versions = await readdir(versionsRoot).catch(() => []);
+  await Promise.all(versions.map(version => rm(mcpPath(path.join(versionsRoot, version)),
+    { force: true })));
 }
 
 /** A plugin tree with the shim written and the skill's command baked in. */
-async function layOutPlugin(target, { runner, node, cli, channel, live }) {
+async function layOutPlugin(target, { runner, node, cli }) {
   await rm(target, { recursive: true, force: true });
   await cp(bundle, target, { recursive: true });
-  // The bundle ships a placeholder .mcp.json; the real one is written only for a
-  // live install, and a non-live tree carries none.
-  await rm(mcpPath(target), { force: true });
-  if (live) await writeChannelMcp(target, { node, channel });
   // The skill ships with a placeholder where the command belongs: `acc` is not
   // on PATH everywhere, and an agent that cannot run it improvises. The shim
   // carries the pinning so each example can name one path. No data home is
@@ -181,9 +176,8 @@ async function layOutPlugin(target, { runner, node, cli, channel, live }) {
     version: await pluginVersion(), io: { readFile, writeFile } });
 }
 
-export async function installClaudePlugin({ configDir, runner, cli, keepPreviousVersion = null, node = process.execPath,
-  channel = defaultChannel(), livePolicy = "off", now = new Date() }) {
-  const live = livePolicy === "actionable" || livePolicy === "all";
+export async function installClaudePlugin({ configDir, runner, cli, keepPreviousVersion = null,
+  node = process.execPath, now = new Date() }) {
   // Everything this will merge into, read before a byte is written. A settings
   // file that will not parse used to be discovered after the plugin tree was
   // already on disk, and the install then failed with nineteen files left
@@ -200,12 +194,12 @@ export async function installClaudePlugin({ configDir, runner, cli, keepPrevious
   const source = sourceDir(configDir);
   const cached = cachePath(configDir, version);
 
-  await layOutPlugin(source, { runner, node, cli, channel, live });
+  await layOutPlugin(source, { runner, node, cli });
   await writeJson(marketplaceFile(configDir), marketplaceManifest());
   // The copy the client runs from. Written here rather than asking the user to
   // run `claude plugin install`, exactly as the Codex adapter does, because the
   // command's only effect is this copy plus the two registry entries below.
-  await layOutPlugin(cached, { runner, node, cli, channel, live });
+  await layOutPlugin(cached, { runner, node, cli });
   // The copy just written, plus the one an upgrade moved off. A client caches a
   // plugin under its version, so every upgrade would otherwise leave the previous
   // release's tree beside this one - invisible while the version never moved,
@@ -214,6 +208,10 @@ export async function installClaudePlugin({ configDir, runner, cli, keepPrevious
   // anything older than that holds no session and is litter.
   await keepVersions({ root: path.dirname(cached), keep: [version, keepPreviousVersion],
     io: { readdir, rm } });
+  // The copy an upgrade moved off stays for sessions already running from it,
+  // but its Channel config would still start a Channel for any session that
+  // reads it. Those sessions keep what they loaded; nothing new starts one.
+  await removeChannelConfig(path.dirname(cached));
 
   await writeClientJson(knownMarketplacesPath(configDir), {
     ...known,
@@ -254,12 +252,9 @@ export async function installClaudePlugin({ configDir, runner, cli, keepPrevious
 
   return { ok: true,
     changes: [source, cached, marketplaceFile(configDir),
-      knownMarketplacesPath(configDir), installedPluginsPath(configDir), file,
-      ...(live ? [mcpPath(source), mcpPath(cached)] : [])],
-    needsAction: live ? [CHANNEL_ACTIVATION_CHECK] : [],
-    diagnostics: live
-      ? ["native channel wired; Claude's experimental development-channel warning still applies"]
-      : [] };
+      knownMarketplacesPath(configDir), installedPluginsPath(configDir), file],
+    needsAction: [],
+    diagnostics: [] };
 }
 
 export async function uninstallClaudePlugin({ configDir, keep = [] }) {
@@ -297,16 +292,15 @@ export async function uninstallClaudePlugin({ configDir, keep = [] }) {
   return { ok: true, changes, diagnostics: [] };
 }
 
-export async function detectClaude({ configDir }) {
+export async function detectClaude({ configDir, managedSettingsPath = MANAGED_SETTINGS[process.platform] }) {
   const settings = await readJson(settingsPath(configDir), null);
   const enabled = settings?.enabledPlugins?.[QUALIFIED] === true;
   const registered = Object.hasOwn(
     (await readJson(installedPluginsPath(configDir), { plugins: {} })).plugins ?? {},
     QUALIFIED);
-  const channelConfigured = enabled && registered
-    && (await readJson(mcpPath(sourceDir(configDir)), null))?.mcpServers?.["acc-channel"] != null;
   return { ok: true, changes: [],
-    needsAction: channelConfigured ? [CHANNEL_ACTIVATION_CHECK] : [],
+    inboundDelivery: await inboundStatus({ configDir, managedSettingsPath }),
+    needsAction: [],
     diagnostics: [enabled && registered
       ? "acc plugin registered and enabled"
       : "acc plugin not registered"] };

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

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

package/node_modules/@agents-can-communicate/adapter-gemini-cli/extension/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-can-communicate",
-  "version": "0.7.1",
+  "version": "0.8.0",
   "description": "Coordinate this Gemini CLI session with other AI agent sessions working in the same workspace.",
   "contextFileName": "skills/acc/SKILL.md"
 }

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

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

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

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

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

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

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

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

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

@@ -4,7 +4,7 @@ import { AccError, EXIT } from "@agents-can-communicate/protocol";
 // so the four cannot drift: a consumer that has to ask which adapter produced an
 // event is a consumer that will eventually get it wrong.
 export const NORMALIZED_EVENT_KEYS = Object.freeze(["kind", "sessionId", "cwd", "model",
-  "parentSessionId", "tool", "targets"]);
+  "parentSessionId", "tool", "targets", "permissionMode", "endReason"]);
 
 export const EVENT_KINDS = Object.freeze(["sessionStart", "sessionEnd", "heartbeat",
   "beforeTurn", "beforeTool", "afterTool", "turnEnd", "childStart", "childEnd", "other"]);
@@ -34,7 +34,7 @@ export function normalizedEvent(fields) {
     }
   }
   const { kind, sessionId, cwd, model = null, parentSessionId = null, tool = null,
-    targets = [] } = fields;
+    targets = [], permissionMode = null, endReason = null } = fields;
 
   if (!EVENT_KINDS.includes(kind)) data("unknown normalised event kind", { kind });
   if (typeof sessionId !== "string" || sessionId === "") {
@@ -50,6 +50,19 @@ export function normalizedEvent(fields) {
     }
   }
 
+  // The client's own name for the session's permission mode, when its hook
+  // reports one. Only a native binding reads it, to tell a sender whether the
+  // client will hold a wake for approval.
+  if (permissionMode !== null && (typeof permissionMode !== "string" || permissionMode === "")) {
+    data("normalised event permission mode must be a non-empty string", { kind });
+  }
+
+  // Why the client ended the session, in its own words, when it says. A sender
+  // is told a conversation was cleared rather than that its peer vanished.
+  if (endReason !== null && (typeof endReason !== "string" || endReason === "")) {
+    data("normalised event end reason must be a non-empty string", { kind });
+  }
+
   return Object.freeze({ kind, sessionId, cwd, model, parentSessionId, tool,
-    targets: Object.freeze([...targets]) });
+    targets: Object.freeze([...targets]), permissionMode, endReason });
 }

package/node_modules/@agents-can-communicate/adapter-sdk/src/hook-shim.mjs

@@ -58,8 +58,6 @@ const ownBinary = name => {
 };
 
 export const defaultRunner = () => ownBinary("acc-hook.mjs");
-export const defaultBootstrap = () => ownBinary("acc-bootstrap.mjs");
-export const defaultChannel = () => ownBinary("acc-claude-channel.mjs");
 export const defaultAntigravityRelay = () => ownBinary("acc-antigravity-relay.mjs");
 
 export const runnerExists = async runner => {
@@ -199,7 +197,10 @@ export async function writeCliShim({ dir, cli = defaultCli(), node = process.exe
  * created, and a recognised path is not a reason to delete it.
  */
 export async function removeInstalledTree(target, keep = []) {
-  if (keep.includes(target)) return false;
+  // A kept tree holds someone's own work. Removing a directory inside it, or one
+  // that contains it, would delete that work as surely as removing it.
+  const within = (inner, outer) => inner === outer || inner.startsWith(`${outer}${path.sep}`);
+  if (keep.some(kept => within(target, kept) || within(kept, target))) return false;
   try {
     await lstat(target);
   } catch (error) {

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

@@ -8,7 +8,7 @@ export { NATIVE_ACTIVATION_KINDS, NATIVE_BINDING_MODES, NATIVE_PLATFORMS, NATIVE
   validateNativeActivationPlan, validateNativeDeliveryContract, validateNativeHandshake }
   from "./native-delivery.mjs";
 export { EVENT_KINDS, NORMALIZED_EVENT_KEYS, normalizedEvent } from "./events.mjs";
-export { assertRunner, bakeSkillCommand, defaultAntigravityRelay, defaultBootstrap, defaultChannel, defaultCli,
+export { assertRunner, bakeSkillCommand, defaultAntigravityRelay, defaultCli,
   defaultRunner, removeInstalledTree, runnerExists, writeCliShim, writeHookShim }
   from "./hook-shim.mjs";
 export { BEGIN, END, removeTomlBlock, renderBlock, stripBlock, tomlString, writeTomlBlock }

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

@@ -1,6 +1,6 @@
 import path from "node:path";
 
-import { COMMAND_NAME, IDENTIFIER, NATIVE_ACTIVATION_KINDS, SHELL_SOURCE, assertReasonCode,
+import { IDENTIFIER, NATIVE_ACTIVATION_KINDS, SHELL_SOURCE, assertReasonCode,
   closed, deepFreeze, isPlainObject, isText, usage } from "./native-vocabulary.mjs";
 
 // A native activation plan is what an adapter hands the installer: closed
@@ -27,19 +27,9 @@ function validateMechanism(mechanism, index) {
     usage(`${label} kind must be one of ${NATIVE_ACTIVATION_KINDS.join(", ")}`);
   }
   if (mechanism.kind === "shell-bootstrap") {
-    closed(mechanism, ["kind", "command", "realExecutable", "prefixArgs"], label);
-    if (!isText(mechanism.command) || !COMMAND_NAME.test(mechanism.command)) {
-      usage(`${label} command must be a bare command name`);
-    }
-    if (!isText(mechanism.realExecutable) || !path.isAbsolute(mechanism.realExecutable)) {
-      usage(`${label} realExecutable must be an absolute path`);
-    }
-    if (!Array.isArray(mechanism.prefixArgs) || mechanism.prefixArgs.some(arg => !isText(arg)
-      || SHELL_SOURCE.test(arg))) {
-      usage(`${label} prefixArgs must be plain argument strings, never shell source`);
-    }
-    return { kind: mechanism.kind, command: mechanism.command,
-      realExecutable: mechanism.realExecutable, prefixArgs: [...mechanism.prefixArgs] };
+    // ACC 0.7.x put a `claude` shim on PATH this way. Install records of it are
+    // still read so it can be retired; a plan can no longer create one.
+    usage(`${label}: shell-bootstrap activation was removed; no adapter may plan one`);
   }
   if (mechanism.kind === "native-config") {
     closed(mechanism, ["kind", "artifactIds"], label);

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

@@ -1,5 +1,5 @@
-import { CONTRACT_ID, FINGERPRINT, HANDSHAKE_KEYS, KNOWN_BAD_REASON, NATIVE_ACTIVATION_KINDS,
-  NATIVE_BINDING_MODES, NATIVE_PLATFORMS, PROBE_KEYS, TIMESTAMP, assertModes,
+import { CONTRACT_ID, FINGERPRINT, HANDSHAKE_KEYS, KNOWN_BAD_REASON, NATIVE_BINDING_MODES,
+  NATIVE_PLATFORMS, PLANNABLE_ACTIVATION_KINDS, PROBE_KEYS, TIMESTAMP, assertModes,
   assertReasonCode, closed, compareStableVersions, deepFreeze, isPlainObject, isText,
   parseStableVersion, usage } from "./native-vocabulary.mjs";
 
@@ -12,19 +12,31 @@ import { CONTRACT_ID, FINGERPRINT, HANDSHAKE_KEYS, KNOWN_BAD_REASON, NATIVE_ACTI
 // 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";
+  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";
+  closed({ ...value, policySource, offerKind },
+    ["minimumByPlatform", "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");
+  }
+  if (!["message", "wake"].includes(offerKind)) {
+    usage("nativeDelivery.offerKind must be message or wake");
   }
   const minimums = value.minimumByPlatform;
   if (!isPlainObject(minimums) || Object.keys(minimums).length === 0) {
@@ -89,11 +101,11 @@ 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 });
+    activationKinds: [...kinds], policySource, offerKind });
 }
 
 function knownBadHit(contract, version) {

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

@@ -9,10 +9,15 @@ 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",
 ]);
 
+// The kinds an adapter may still ask for.
+export const PLANNABLE_ACTIVATION_KINDS = Object.freeze(["native-config", "native-service"]);
+
 export const NATIVE_PLATFORMS = Object.freeze([
   "darwin-arm64", "darwin-x64", "linux-arm64", "linux-x64", "win32-x64",
 ]);
@@ -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.0",
   "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,16 @@ 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.
+  const waiting = (status.participants ?? []).filter(item => item.presence === "offline")
+    .map(item => {
+      const count = (item.unretrieved?.queued ?? 0) + (item.unretrieved?.offered ?? 0);
+      return `${item.participantId} (${item.endReason === "clear" ? "cleared, " : ""}${count})`;
+    });
+  return waiting.length === 0 ? withOffers
+    : `${withOffers}; waiting for a closed session: ${waiting.join(", ")}`;
 }
 
 const HANDLERS = Object.freeze({