agents-can-communicate 0.7.0 → 0.8.0

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

@@ -0,0 +1,109 @@
+import { execFile } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+
+// What Claude Code does with a wake from a sender that attests no permission
+// mode - ACC never attests one. A session that bypasses permission prompts
+// holds it for approval; `crossSessionInbound` overrides that both ways. ACC
+// reads the same inputs so the sender is told what will happen, and never
+// changes any of them.
+
+const MAX_BYTES = 256 * 1024;
+const RECEPTIONS = Object.freeze(["delivered", "held", "refused"]);
+
+export const MANAGED_SETTINGS = Object.freeze({
+  darwin: "/Library/Application Support/ClaudeCode/managed-settings.json",
+  linux: "/etc/claude-code/managed-settings.json",
+  win32: "C:\\Program Files\\ClaudeCode\\managed-settings.json",
+});
+
+async function readSettings(file) {
+  try {
+    const text = await readFile(file, "utf8");
+    if (Buffer.byteLength(text) > MAX_BYTES) return null;
+    const value = JSON.parse(text);
+    return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+const text = value => (typeof value === "string" && value !== "" ? value : null);
+
+/**
+ * The two inputs, each from the first file that sets it, in Claude Code's own
+ * order: managed policy, then the project's local and shared settings, then
+ * the user's.
+ */
+export async function readInboundSettings({ configDir, projectDir, managedSettingsPath }) {
+  const files = [managedSettingsPath,
+    ...(typeof projectDir === "string" && path.isAbsolute(projectDir)
+      ? [path.join(projectDir, ".claude", "settings.local.json"),
+        path.join(projectDir, ".claude", "settings.json")] : []),
+    path.join(configDir, "settings.json")].filter(file => typeof file === "string");
+  const layers = await Promise.all(files.map(readSettings));
+  const first = pick => layers.map(layer => (layer === null ? null : pick(layer))).find(value => value !== null)
+    ?? null;
+  return {
+    crossSessionInbound: first(layer => text(layer.crossSessionInbound)),
+    defaultMode: first(layer => text(layer.permissions?.defaultMode)),
+  };
+}
+
+/**
+ * The permission mode a Claude Code process was started with, from its own
+ * arguments, or null. Only the two flags are read; nothing else is kept.
+ */
+export function permissionModeFromArgs(args) {
+  if (!Array.isArray(args)) return null;
+  for (let index = 0; index < args.length; index += 1) {
+    const arg = args[index];
+    if (arg === "--dangerously-skip-permissions") return "bypassPermissions";
+    if (arg === "--permission-mode") return text(args[index + 1]);
+    if (typeof arg === "string" && arg.startsWith("--permission-mode=")) {
+      return text(arg.slice("--permission-mode=".length));
+    }
+  }
+  return null;
+}
+
+/** A process's arguments as `ps` prints them, split on spaces, or null. */
+export function readProcessArgs(pid, { timeoutMs = 500 } = {}) {
+  if (!Number.isInteger(pid) || pid <= 0 || process.platform === "win32") return Promise.resolve(null);
+  return new Promise(resolve => {
+    execFile("ps", ["-o", "args=", "-p", String(pid)], { timeout: timeoutMs, maxBuffer: 64 * 1024 },
+      (error, stdout) => resolve(error ? null : String(stdout).trim().split(/\s+/).filter(Boolean)));
+  });
+}
+
+export function receptionOf({ permissionMode, crossSessionInbound }) {
+  if (crossSessionInbound === "accept") return "delivered";
+  if (crossSessionInbound === "refuse") return "refused";
+  if (crossSessionInbound === "hold" || permissionMode === "bypassPermissions") return "held";
+  return "delivered";
+}
+
+export const isReception = value => RECEPTIONS.includes(value);
+
+/**
+ * What `acc doctor` tells a person who turned live delivery on: the machine-wide
+ * view, from managed policy and the user's settings. A project can still set
+ * its own value; the bind reads that one per session.
+ */
+export async function inboundStatus({ configDir, managedSettingsPath }) {
+  const userFile = path.join(configDir, "settings.json");
+  for (const file of [managedSettingsPath, userFile].filter(item => typeof item === "string")) {
+    const value = text((await readSettings(file))?.crossSessionInbound);
+    if (value === "accept") return { state: "accepted", diagnostic: null };
+    if (value === "refuse") {
+      return { state: "refused", diagnostic: `crossSessionInbound is "refuse" in ${file}, so `
+        + "Claude Code drops every ACC wake; messages arrive with each next turn; set it to "
+        + "\"accept\" for live delivery" };
+    }
+    if (value !== null) break;
+  }
+  return { state: "attention", diagnostic: "a session that bypasses permission prompts asks "
+    + `before each ACC wake; add "crossSessionInbound": "accept" to ${userFile} to take wakes `
+    + "without asking; the next turn shows the message either way" };
+}
+

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.0",
+  "version": "0.8.0",
   "private": true,
   "type": "module",
   "exports": {

package/node_modules/@agents-can-communicate/adapter-codex/plugin/skills/acc/SKILL.md

@@ -111,6 +111,10 @@ the communication obligation rather than proving the requested action is complet
 An acknowledgement confirms receipt, not acceptance of work. Read the peer's
 answer for the scope it accepted or the result it actually checked.
 
+To see where a message you sent got to, read it exactly:
+`{{ACC}} sync --scope history --message <id> --json` lists each recipient's
+receipt state, when it last changed, and the transport that offered it.
+
 ## Read and answer only your inbox
 
 Plain `{{ACC}} inbox` returns `{items, nextCursor}`: pending message headers,
@@ -125,6 +129,10 @@ Pages default to 20 items and stay within 12,000 bytes of formatted page JSON.
 Use `inbox --cursor <nextCursor>` for older headers when needed. Omit the cursor
 on a new poll to see arrivals; a cursor is the complete last message id, not an offset.
 
+A peer block with a `repeat:` line was pushed live earlier and nothing has
+retrieved it since. A note you already acted on needs nothing more; for a
+message that asks for one, a reply or acknowledgement is still owed.
+
 An injected peer block is already the message body. If context was compacted,
 or a body did not fit, retrieve exactly the named message:
 

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

@@ -1,6 +1,6 @@
 {
   "name": "agents-can-communicate",
-  "version": "0.7.0",
+  "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/extension/skills/acc/SKILL.md

@@ -111,6 +111,10 @@ the communication obligation rather than proving the requested action is complet
 An acknowledgement confirms receipt, not acceptance of work. Read the peer's
 answer for the scope it accepted or the result it actually checked.
 
+To see where a message you sent got to, read it exactly:
+`{{ACC}} sync --scope history --message <id> --json` lists each recipient's
+receipt state, when it last changed, and the transport that offered it.
+
 ## Read and answer only your inbox
 
 Plain `{{ACC}} inbox` returns `{items, nextCursor}`: pending message headers,
@@ -125,6 +129,10 @@ Pages default to 20 items and stay within 12,000 bytes of formatted page JSON.
 Use `inbox --cursor <nextCursor>` for older headers when needed. Omit the cursor
 on a new poll to see arrivals; a cursor is the complete last message id, not an offset.
 
+A peer block with a `repeat:` line was pushed live earlier and nothing has
+retrieved it since. A note you already acted on needs nothing more; for a
+message that asks for one, a reply or acknowledgement is still owed.
+
 An injected peer block is already the message body. If context was compacted,
 or a body did not fit, retrieve exactly the named message:
 

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.0",
+  "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.0",
+  "version": "0.8.0",
   "private": true,
   "type": "module",
   "exports": {

package/node_modules/@agents-can-communicate/adapter-grok/plugin/skills/acc/SKILL.md

@@ -127,6 +127,10 @@ the communication obligation rather than proving the requested action is complet
 An acknowledgement confirms receipt, not acceptance of work. Read the peer's
 answer for the scope it accepted or the result it actually checked.
 
+To see where a message you sent got to, read it exactly:
+`{{ACC}} sync --scope history --message <id> --json` lists each recipient's
+receipt state, when it last changed, and the transport that offered it.
+
 ## Read and answer only your inbox
 
 Plain `{{ACC}} inbox` returns `{items, nextCursor}`: pending message headers,
@@ -141,6 +145,10 @@ Pages default to 20 items and stay within 12,000 bytes of formatted page JSON.
 Use `inbox --cursor <nextCursor>` for older headers when needed. Omit the cursor
 on a new poll to see arrivals; a cursor is the complete last message id, not an offset.
 
+A peer block with a `repeat:` line was pushed live earlier and nothing has
+retrieved it since. A note you already acted on needs nothing more; for a
+message that asks for one, a reply or acknowledgement is still owed.
+
 An injected peer block is already the message body. If context was compacted,
 or a body did not fit, retrieve exactly the named message:
 

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

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

package/node_modules/@agents-can-communicate/adapter-kimi/plugin/skills/acc/SKILL.md

@@ -111,6 +111,10 @@ the communication obligation rather than proving the requested action is complet
 An acknowledgement confirms receipt, not acceptance of work. Read the peer's
 answer for the scope it accepted or the result it actually checked.
 
+To see where a message you sent got to, read it exactly:
+`{{ACC}} sync --scope history --message <id> --json` lists each recipient's
+receipt state, when it last changed, and the transport that offered it.
+
 ## Read and answer only your inbox
 
 Plain `{{ACC}} inbox` returns `{items, nextCursor}`: pending message headers,
@@ -125,6 +129,10 @@ Pages default to 20 items and stay within 12,000 bytes of formatted page JSON.
 Use `inbox --cursor <nextCursor>` for older headers when needed. Omit the cursor
 on a new poll to see arrivals; a cursor is the complete last message id, not an offset.
 
+A peer block with a `repeat:` line was pushed live earlier and nothing has
+retrieved it since. A note you already acted on needs nothing more; for a
+message that asks for one, a reply or acknowledgement is still owed.
+
 An injected peer block is already the message body. If context was compacted,
 or a body did not fit, retrieve exactly the named message:
 

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

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

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

@@ -51,7 +51,18 @@ function offeredBreadcrumb(item, liveOfferedMessageIds) {
     + `\`acc inbox --message ${item.sourceId}\``;
 }
 
-function messageGroups(messages) {
+// A body shown again because a live transport accepted it and nothing followed.
+// Said inside the block so the model can match it to what it may already have.
+function repeatLines(message, repeats) {
+  const repeat = repeats.get(message.messageId);
+  // Both values come from the store, and the store is shared with every peer's
+  // process, so they are escaped like any other line inside the block.
+  return repeat === undefined ? []
+    : [oneLine(escapePeerText(`repeat: offered via ${repeat.transport} at ${repeat.at}; `
+      + "no retrieval recorded"))];
+}
+
+function messageGroups(messages, repeats = new Map()) {
   return messages.map(message => ({
     messageId: message.messageId,
     kind: "message",
@@ -63,6 +74,7 @@ function messageGroups(messages) {
       `messageId: ${message.messageId}`,
       `sender: ${message.fromParticipantId} (session ${message.fromSessionId})`,
       `obligation: ${message.obligation}`,
+      ...repeatLines(message, repeats),
       ...decisionLines(message).map(escapePeerText),
       `subject: ${oneLine(escapePeerText(message.subject))}`,
       "body:",
@@ -129,7 +141,8 @@ export function projectContextResult(sync, { budgetBytes = DEFAULT_BUDGET_BYTES
   const liveOfferedMessageIds = new Set(sync.liveOfferedMessageIds ?? []);
   const groups = [
     ...attentionGroups(urgent, { truncatable: true, liveOfferedMessageIds }),
-    ...messageGroups(messages),
+    ...messageGroups(messages, new Map((sync.repeatOffers ?? [])
+      .map(repeat => [repeat.messageId, repeat]))),
     ...reminderGroups(attention.filter(isReminder)),
     ...attentionGroups(informational, { truncatable: false }),
   ];

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.0",
+  "version": "0.8.0",
   "private": true,
   "type": "module",
   "exports": {