agents-can-communicate 0.1.17 → 0.2.0

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

@@ -1,277 +1,192 @@
 const DEFAULT_BUDGET_BYTES = 6_000;
-// Held back from the required lines so the "not shown" note can always be
-// written. A projection that silently drops what it could not fit is how an
-// agent ends up confidently unaware.
-// Enough for the note *and* the command that reads what the note is about. It
-// said only that something had been withheld, and nothing anywhere - not the
-// skills, not the docs - said how to see it. A turn that reports a thing the
-// reader cannot reach is how an agent ends up inventing its own way in.
-// Enough for the longest over-budget note - the escalated "message did not fit"
-// line, which is longer than the plain "+N not shown" it replaces. Kept small
-// enough that the note still fits beside a header at the smallest budgets.
-const NOTE_RESERVE = 90;
 const FENCE = "```";
-// A peer cannot close a block it cannot name. The fence carries a marker that
-// is stripped from peer content, so forged delimiters stay inside the block.
 const BLOCK = "acc-peer-message";
 
 const bytes = value => Buffer.byteLength(value, "utf8");
-
-// Written from char codes rather than a literal class: an escaped control
-// range in a regex literal is corrupted silently by editors and patches, and a
-// corrupted range fails open.
 const CONTROL_CHARACTERS = new RegExp(
   `[${String.fromCharCode(0)}-${String.fromCharCode(8)}`
   + `${String.fromCharCode(11)}-${String.fromCharCode(31)}${String.fromCharCode(127)}]`, "g");
 
-/**
- * Render peer-controlled text as displayable data.
- *
- * Two separate jobs. Control sequences become visible escapes, so a message
- * cannot repaint or retitle the human's terminal. Fence markers are stripped,
- * so a message cannot break out of its own data block and continue as if ACC
- * had written the following lines.
- */
 function escapePeerText(value) {
   return String(value)
     .replaceAll(new RegExp(`${FENCE}${BLOCK}`, "g"), `'${FENCE}${BLOCK}`)
     .replaceAll(FENCE, `'${FENCE}`)
-    // The labels that frame this block are ACC's words at the start of a line.
-    // A peer writing one would otherwise produce a second line reading as ACC
-    // framing a different message - the same break-out the fence rule prevents,
-    // and neutralised the same way rather than by reflowing the text, which a
-    // handoff body cannot survive.
     .replace(/^(subject:|body:)/gm, "'$1")
     .replace(CONTROL_CHARACTERS,
       character => `\\u${character.codePointAt(0).toString(16).padStart(4, "0")}`);
 }
 
+function oneLine(value) {
+  return value.replaceAll("\r\n", "\\n").replaceAll("\n", "\\n").replaceAll("\r", "\\n");
+}
+
 function truncate(line, limit) {
+  if (limit <= 0) return "";
   if (bytes(line) <= limit) return line;
   let cut = line;
   while (bytes(`${cut}…`) > limit && cut.length > 0) cut = cut.slice(0, -1);
-  return `${cut}…`;
+  return cut === "" ? "" : `${cut}…`;
 }
 
-/**
- * An attention line an agent can act on without a round trip.
- *
- * `- [task_unblocked] Tank sinks through mud` says work is waiting and does not
- * say which work. The commands that take it - `acc task --take --task <id>` -
- * all need the id, and the only other place it appears is `acc sync --json`. An
- * agent that is told to act and not told on what improvises, which in this
- * project has already meant one hand-editing the store rather than admitting it
- * could not name the task.
- *
- * Every kind carries such an id and every one is the argument to a command:
- * a message to `acc ack --message`, a task to `acc task --task`, a claim to
- * `acc release --claim`. So they are all shown, not only the ones that happened
- * to be noticed first.
- */
-function attentionLines(attention) {
-  return attention.map(item => (typeof item.sourceId === "string" && item.sourceId !== ""
-    ? `- [${item.kind}] ${item.sourceId} ${item.summary}`
-    : `- [${item.kind}] ${item.summary}`));
+function attentionGroups(attention, { truncatable, liveOfferedMessageIds = new Set() }) {
+  return attention.map(item => {
+    const breadcrumb = offeredBreadcrumb(item, liveOfferedMessageIds);
+    return {
+      lines: [breadcrumb ?? (typeof item.sourceId === "string" && item.sourceId !== ""
+        ? `- [${item.kind}] ${item.sourceId} ${item.summary}`
+        : `- [${item.kind}] ${item.summary}`)],
+      kind: "attention",
+      sourceId: item.sourceId ?? null,
+      truncatable: breadcrumb === null && truncatable,
+    };
+  });
 }
 
-/**
- * Claims other sessions hold, and whether this session can be stopped from
- * breaking them.
- *
- * Ranked with the required lines rather than the roster, because a claim is
- * what changes what this session should do next. When it cannot be enforced -
- * a model that edits through the shell, an MCP client with no hooks - saying so
- * is the whole mitigation: ACC will not intercept the write, so respecting the
- * claim is this session's own responsibility and it needs to know that.
- */
-function claimNote(claim) {
-  // Enforcement is declared per claim, and the guard only ever blocks a guarded
-  // one. Reading this session's capability alone would announce a block that
-  // will never happen, on a claim whose owner explicitly did not ask for one.
-  if (claim.enforcement !== "guarded") {
-    return " - advisory; nothing will stop you, the owner is asking";
-  }
-  if (claim.enforceable === false) {
-    return " - not enforced for this session; do not edit it";
-  }
-  // Guarded, and this session can be stopped - on a file edit, and on the shell
-  // writes the guard can read: a redirection, an operand of a command whose job
-  // is to put bytes somewhere. A language runtime opening the file itself still
-  // gets past, and a session told merely "this is claimed" would reasonably
-  // assume either more or less than is true.
-  return " - file edits and recognised shell writes are blocked; a runtime can still get past";
+function offeredBreadcrumb(item, liveOfferedMessageIds) {
+  if (!liveOfferedMessageIds.has(item.sourceId)) return null;
+  const noun = item.kind === "reply_required" ? "question"
+    : item.kind === "acknowledgement_required" ? "message" : null;
+  if (noun === null) return null;
+  return `- [${item.kind}] ${item.sourceId} live-offered peer ${noun} remains unresolved; `
+    + `\`acc inbox --message ${item.sourceId}\``;
 }
 
-function claimLines(claims) {
-  return claims.map(claim => {
-    const owner = claim.ownerParticipantId ?? claim.ownerSessionId ?? "another session";
-    return `- [claim] ${claim.resource} held by ${owner}${claimNote(claim)}`;
-  });
+function messageGroups(messages) {
+  return messages.map(message => ({
+    messageId: message.messageId,
+    kind: "message",
+    lines: [
+      `${FENCE}${BLOCK}`,
+      "untrusted peer message",
+      `kind: ${message.kind}`,
+      `threadId: ${message.threadId}`,
+      `messageId: ${message.messageId}`,
+      `sender: ${message.fromParticipantId} (session ${message.fromSessionId})`,
+      `obligation: ${message.obligation}`,
+      `subject: ${oneLine(escapePeerText(message.subject))}`,
+      "body:",
+      escapePeerText(message.body),
+      FENCE,
+    ],
+  }));
 }
 
-/**
- * One group per message, never a flat list of lines.
- *
- * A block that the budget cuts in half is worse than a block that was left out:
- * the fence never closes, and everything after it reads as ACC's own words
- * rather than as a peer's. So a message is included whole or not at all.
- *
- * The id is carried because the reader needs it to acknowledge the message, and
- * because the caller needs it to tell which messages actually reached the model
- * before recording any of them as delivered. Ids, session ids and types are
- * generated or schema-validated; only the subject and body are peer-authored,
- * and only those are escaped.
- */
-function peerBlocks(messages) {
-  return messages.map(message => [
-    `${FENCE}${BLOCK}`,
-    `id ${message.messageId} | from ${message.fromSessionId} | type ${message.type}`
-    + " | untrusted peer message",
-    `subject: ${oneLine(escapePeerText(message.subject))}`,
-    "body:",
-    escapePeerText(message.body),
-    FENCE,
-  ]);
+const groupBytes = group => group.lines.reduce((total, line) => total + bytes(line) + 1, 0);
+
+function peerCount(sync) {
+  const participants = new Set((sync.roster ?? [])
+    .filter(item => item.presence !== "offline")
+    .map(item => item.participantId ?? item.sessionId)
+    .filter(id => id !== sync.currentParticipantId));
+  return participants.size;
 }
 
-/**
- * A subject is one line, whatever the peer sent.
- *
- * The subject sits on the label's own line, so a newline inside it would push
- * peer text to column 0 where ACC's labels live. Rendering the break visibly
- * keeps the text readable and the frame ACC's.
- */
-function oneLine(value) {
-  return value.replaceAll("\r\n", "\\n").replaceAll("\n", "\\n").replaceAll("\r", "\\n");
+function ambientHeader(count) {
+  const noun = count === 1 ? "participant" : "participants";
+  return `ACC: ${count} peer ${noun} present. Load the acc skill before shared work.`;
 }
 
+function recoveryNote(ids) {
+  const first = ids[0];
+  const rest = ids.length > 1 ? ` (+${ids.length - 1} more in \`acc inbox\`)` : "";
+  return `- read ${first}: \`acc inbox --message ${first}\`${rest}`;
+}
 
 /**
- * Project a SyncResult into bounded text for one adapter to inject.
+ * Project only coordination that can change this turn.
  *
- * Priority is fixed: direct requests and conflicts first, roster detail last,
- * because the budget is spent from the bottom. Whatever is dropped is counted
- * rather than silently removed - a projection that hides its own omissions is
- * how an agent ends up confidently unaware.
+ * Presence is a short trigger to load the ACC skill. Roster rows and unrelated
+ * claims are intentionally absent: a guard checks exact file claims at write
+ * time, while intent-aware conflicts already arrive as attention. Repeating
+ * the whole workspace on every prompt is neither safer nor cheaper.
  */
-export function projectContext(sync, { budgetBytes = DEFAULT_BUDGET_BYTES } = {}) {
+export function projectContextResult(sync, { budgetBytes = DEFAULT_BUDGET_BYTES } = {}) {
   const attention = [...(sync.attention ?? [])]
     .sort((left, right) => left.priority - right.priority
-      || left.sourceId.localeCompare(right.sourceId));
+      || (left.sourceId ?? "").localeCompare(right.sourceId ?? ""));
+  const leadsPeerBodies = item => item.priority <= 2 || item.kind === "claim_conflict";
+  const urgent = attention.filter(leadsPeerBodies);
+  const informational = attention.filter(item => !leadsPeerBodies(item));
   const messages = sync.messages ?? [];
-  // Who is here, which is not the same as who has ever been here. The roster
-  // keeps closed sessions - `sync` needs them to decide what a cursor has missed
-  // - and a turn that lists them says "3 session(s)" for two participants, one
-  // of them shown twice with contradictory presence. Left alone it also grows
-  // without limit: every session ever opened would take a line out of the
-  // context budget, crowding out messages actually addressed to the reader.
-  // Stale stays: a session that crashed holding a claim is very much news.
-  const roster = (sync.roster ?? []).filter(item => item.presence !== "offline");
-  const claims = sync.claims ?? [];
-
-  // Every entry is a group that appears whole or not at all. Single-line groups
-  // may still be truncated - there is no fence in them to leave open. `message`
-  // is carried so a dropped message can be counted apart from a dropped
-  // reminder: the two are not the same news.
-  //
-  // A peer message sits after "act now" attention (a direct request, an imminent
-  // conflict: priority <= 2) and ahead of standing reminders. The order is the
-  // fix for a real starvation: an expired-claim line (priority 6) regenerates
-  // from state every turn, while a message is delivered once and its receipt
-  // then stops it appearing - so a reminder that never clears must not keep
-  // pushing a one-time message into the over-budget overflow, turn after turn,
-  // where two agents each lost their most important message to it.
-  const urgent = attention.filter(item => item.priority <= 2);
-  const info = attention.filter(item => item.priority > 2);
-  const required = [
-    ...attentionLines(urgent).map(line => ({ lines: [line], message: false })),
-    ...peerBlocks(messages).map(block => ({ lines: block, message: true })),
-    ...attentionLines(info).map(line => ({ lines: [line], message: false })),
-    ...claimLines(claims).map(line => ({ lines: [line], message: false })),
+  const liveOfferedMessageIds = new Set(sync.liveOfferedMessageIds ?? []);
+  const groups = [
+    ...attentionGroups(urgent, { truncatable: true, liveOfferedMessageIds }),
+    ...messageGroups(messages),
+    ...attentionGroups(informational, { truncatable: false }),
   ];
-  // Solo costs nothing: a lone session pays no visible price, and "no peers" is
-  // still a cost when injected into every turn. But this is decided after the
-  // required lines are built, not before - a message already addressed to you,
-  // or a claim you could break, is not nothing, and returning early swallowed
-  // exactly the things worth saying to someone working alone.
-  if (sync.solo === true && required.length === 0) return "";
-
-  // Named by participant, because that is what another agent addresses work to
-  // - a session id cannot be used with `--to`. The branch says where they are,
-  // which is how a workspace spanning several worktrees stays legible.
-  const optional = roster.map(item => {
-    const who = item.participantId ?? item.sessionId;
-    const place = item.branch === null || item.branch === undefined
-      ? ""
-      : ` on ${item.branch}`;
-    return `- ${who}${place} (${item.harness}, ${item.presence})`;
-  });
-
-  const header = `${roster.length} session(s); cursor ${sync.cursor}`;
-  const lines = [header];
-  let used = bytes(header);
+  const peers = peerCount(sync);
+  if (groups.length === 0 && (sync.solo === true || peers === 0)) {
+    return { text: "", offeredMessageIds: [], includedAttentionIds: [] };
+  }
 
-  // Reserved so the note below always fits. Without it the projection could run
-  // out of room to say that it ran out of room.
-  const ceiling = budgetBytes - NOTE_RESERVE;
+  const fullHeader = groups.length === 0 ? ambientHeader(peers) : "ACC (load the acc skill):";
+  const header = truncate(fullHeader, budgetBytes);
+  const lines = header === "" ? [] : [header];
+  let used = header === "" ? 0 : bytes(header) + 1;
+  const included = [];
+  const droppedMessages = [];
   let droppedOther = 0;
-  let droppedMessages = 0;
-  const drop = group => { if (group.message) droppedMessages += 1; else droppedOther += 1; };
-  for (const group of required) {
-    const block = group.lines;
-    if (block.length === 1) {
-      const candidate = truncate(block[0], Math.max(0, ceiling - used - 1));
-      if (candidate === "" || used + bytes(candidate) + 1 > ceiling) { drop(group); continue; }
-      lines.push(candidate);
-      used += bytes(candidate) + 1;
+
+  for (const group of groups) {
+    if (group.lines.length === 1) {
+      const remaining = budgetBytes - used;
+      const line = group.truncatable
+        ? truncate(group.lines[0], remaining)
+        : (bytes(group.lines[0]) <= remaining ? group.lines[0] : "");
+      if (line !== "" && used + bytes(line) <= budgetBytes) {
+        lines.push(line);
+        included.push({ group, lineCount: 1 });
+        used += bytes(line) + 1;
+      } else {
+        droppedOther += 1;
+      }
       continue;
     }
-    const size = block.reduce((total, line) => total + bytes(line) + 1, 0);
-    // Skipped rather than stopped at: the groups are ordered by priority, and a
-    // large message must not hide the shorter ones behind it.
-    if (used + size > ceiling) { drop(group); continue; }
-    lines.push(...block);
-    used += size;
-  }
-  // A dropped message is louder than a dropped reminder: "+N not shown" read as
-  // noise to two agents who each lost their most important message to it, so a
-  // message that did not fit says so specifically and names the command that
-  // recovers it. One note either way, escalated when a message is among the loss.
-  // The note is guarded against the budget, not merely reserved for: at a
-  // pathologically small budget the header alone can leave less room than the
-  // note needs, and a projection that overran the very budget it exists to
-  // respect is the bug this whole function is careful about. If the full note
-  // will not fit, the shortest imperative that does is still not silence.
-  const pushNote = note => {
-    const short = "- ⚠ over budget; `acc sync --scope full --json`";
-    for (const candidate of [note, short]) {
-      if (used + bytes(candidate) + 1 <= budgetBytes) {
-        lines.push(candidate);
-        used += bytes(candidate) + 1;
-        return;
-      }
+    const size = groupBytes(group);
+    if (used + size <= budgetBytes) {
+      lines.push(...group.lines);
+      included.push({ group, lineCount: group.lines.length });
+      used += size;
+    } else {
+      droppedMessages.push(group.messageId);
     }
-  };
-  if (droppedMessages > 0) {
-    // No count of the other drops: `--scope full` recovers everything.
-    pushNote(`- ⚠ ${droppedMessages} message(s) addressed to you did not fit; `
-      + "run `acc sync --scope full --json`");
-  } else if (droppedOther > 0) {
-    pushNote(`- +${droppedOther} not shown, over budget; read them with `
-      + "`acc sync --scope full --json`");
   }
 
-  let shown = 0;
-  for (const line of optional) {
-    if (used + bytes(line) + 1 > budgetBytes - 16) break;
-    lines.push(line);
-    used += bytes(line) + 1;
-    shown += 1;
-  }
-  if (shown < optional.length) {
-    const note = `- +${optional.length - shown} more`;
+  if (droppedMessages.length > 0) {
+    let note = recoveryNote(droppedMessages);
+    while (used + bytes(note) + 1 > budgetBytes && included.length > 0) {
+      const removed = included.pop();
+      lines.splice(-removed.lineCount, removed.lineCount);
+      used = lines.reduce((total, line) => total + bytes(line) + 1, 0);
+      if (removed.group.kind === "message") droppedMessages.push(removed.group.messageId);
+      else droppedOther += 1;
+      note = recoveryNote([...new Set(droppedMessages)]);
+    }
+    if (used + bytes(note) + 1 > budgetBytes && lines.length > 0) {
+      lines.length = 0;
+      used = 0;
+    }
+    const fitted = recoveryNote([...new Set(droppedMessages)]);
+    // An incomplete id or command is not a recovery path. When a deliberately
+    // tiny budget cannot hold the shortest truthful instruction, say nothing
+    // and leave every omitted receipt queued for a later turn.
+    if (used + bytes(fitted) + 1 <= budgetBytes) lines.push(fitted);
+  } else if (droppedOther > 0) {
+    const note = `- +${droppedOther} actionable item(s) omitted; run \`acc status --json\``;
     if (used + bytes(note) + 1 <= budgetBytes) lines.push(note);
   }
 
-  return lines.join("\n");
+  return {
+    text: lines.join("\n"),
+    offeredMessageIds: included
+      .filter(item => item.group.kind === "message")
+      .map(item => item.group.messageId),
+    includedAttentionIds: included
+      .filter(item => item.group.kind === "attention" && item.group.sourceId !== null)
+      .map(item => item.group.sourceId),
+  };
+}
+
+export function projectContext(sync, options) {
+  return projectContextResult(sync, options).text;
 }

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

@@ -1,4 +1,4 @@
-import { access, chmod, mkdir, readFile, readdir, rm, writeFile }
+import { access, chmod, lstat, mkdir, readFile, readdir, rm, writeFile }
   from "node:fs/promises";
 import { existsSync } from "node:fs";
 import path from "node:path";
@@ -147,6 +147,12 @@ export async function writeHookShim({ dir, adapterId, runner = defaultRunner(),
  */
 export async function removeInstalledTree(target, keep = []) {
   if (keep.includes(target)) return false;
+  try {
+    await lstat(target);
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  }
   await rm(target, { recursive: true, force: true });
   return true;
 }

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

@@ -1,13 +1,14 @@
 // Capability contract, context projection, config ownership, and the binding
 // that survives between two ephemeral hook processes.
 export { CAPABILITY_SHAPE, assertCapabilities, defineAdapter } from "./capabilities.mjs";
+export { effectiveCapabilities, validateCertification } from "./certification.mjs";
 export { EVENT_KINDS, NORMALIZED_EVENT_KEYS, normalizedEvent } from "./events.mjs";
 export { assertRunner, bakeSkillCommand, defaultCli, defaultRunner, removeInstalledTree,
   runnerExists, writeHookShim }
   from "./hook-shim.mjs";
 export { BEGIN, END, removeTomlBlock, renderBlock, stripBlock, tomlString, writeTomlBlock }
   from "./toml-block.mjs";
-export { projectContext } from "./context-projector.mjs";
+export { projectContext, projectContextResult } from "./context-projector.mjs";
 export { shellWriteTargets } from "./shell-writes.mjs";
 export { keepOnlyVersion, ownVersion, stampPluginVersion } from "./own-version.mjs";
 export { editJson, readJson } from "./json-text.mjs";

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

@@ -18,13 +18,16 @@ const fileFor = (runtimeDir, harnessSessionId) => path.join(runtimeDir, "binding
  * detach the exact generation instead of opening a second session.
  *
  * It lives in the runtime directory, never the project, and carries identity
- * only - no prompt, no transcript, no harness state.
+ * plus the exact client facts observed at attach time - no prompt, transcript,
+ * or harness state.
  */
 export async function storeSessionBinding({ runtimeDir, harnessSessionId, accSessionId,
-  generation }) {
+  generation, clientVersion, platform }) {
   const file = fileFor(runtimeDir, harnessSessionId);
   await mkdir(path.dirname(file), { recursive: true });
   const record = { schemaVersion: SCHEMA_VERSION, harnessSessionId, accSessionId, generation };
+  if (typeof clientVersion === "string" && clientVersion !== "") record.clientVersion = clientVersion;
+  if (typeof platform === "string" && platform !== "") record.platform = platform;
   const temporary = `${file}.${process.pid}.tmp`;
   await writeFile(temporary, `${JSON.stringify(record, null, 2)}\n`, "utf8");
   // Replace rather than append: re-attaching supersedes the old generation, and
@@ -54,7 +57,10 @@ export async function loadSessionBinding({ runtimeDir, harnessSessionId }) {
     throw new AccError(EXIT.DATA, "unknown session binding schemaVersion",
       { file, schemaVersion: record?.schemaVersion });
   }
-  return { accSessionId: record.accSessionId, generation: record.generation };
+  const binding = { accSessionId: record.accSessionId, generation: record.generation };
+  if (typeof record.clientVersion === "string") binding.clientVersion = record.clientVersion;
+  if (typeof record.platform === "string") binding.platform = record.platform;
+  return binding;
 }
 
 export async function clearSessionBinding({ runtimeDir, harnessSessionId }) {
@@ -89,7 +95,10 @@ export async function listSessionBindings({ runtimeDir }) {
       .then(JSON.parse).catch(() => null);
     if (record?.schemaVersion !== SCHEMA_VERSION) continue;
     bindings.push({ harnessSessionId: record.harnessSessionId,
-      accSessionId: record.accSessionId, generation: record.generation });
+      accSessionId: record.accSessionId, generation: record.generation,
+      ...(typeof record.clientVersion === "string"
+        ? { clientVersion: record.clientVersion } : {}),
+      ...(typeof record.platform === "string" ? { platform: record.platform } : {}) });
   }
   return bindings;
 }

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

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

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

@@ -14,7 +14,7 @@ export const COMMANDS = Object.freeze({
   detach: { required: ["session", "generation"], optional: [] },
   sync: { required: [], optional: ["session", "cursor", "limit", "scope"] },
   work: { required: [], optional: ["session", "generation", "summary", "mode",
-    "state", "workstream"], repeated: ["hint"], flags: ["clear"] },
+    "state"], repeated: ["hint"], flags: ["clear"] },
   claim: { required: ["resource"],
     optional: ["session", "generation", "mode", "enforcement", "reason", "lease"] },
   // Neither is required on its own, because either one names the claim: an id
@@ -24,34 +24,17 @@ export const COMMANDS = Object.freeze({
   release: { required: [],
     optional: ["claim", "resource", "session", "generation", "authority", "reason"] },
   message: { required: ["subject", "body"],
-    optional: ["session", "generation", "type", "priority", "workstream"],
-    repeated: ["to"], flags: ["requires-ack"] },
-  // Asking another agent to do something: one call, because a task nobody was
-  // told about and a message pointing at no task are each useless.
+    optional: ["session", "generation", "type", "obligation", "client-message-id"],
+    repeated: ["to"] },
+  inbox: { required: [], optional: ["session", "generation", "message"] },
+  reply: { required: ["message", "body"],
+    optional: ["session", "generation", "subject", "client-message-id"] },
+  // Asking another agent to do something as a message with a reply obligation.
   request: { required: ["to", "title"],
-    optional: ["session", "generation", "detail", "workstream", "priority"],
-    repeated: ["depends-on"] },
-  // Create a task, or act on one with --task. A workstream is optional: small
-  // requests should not have to invent a project first.
-  task: { required: [], optional: ["session", "generation", "workstream", "title",
-    "detail", "assignee", "state", "task", "reason"],
-    repeated: ["depends-on"], flags: ["take", "decline", "force"] },
-  // Create one, or take and hand back the coordination of one that exists.
-  // Creating a workstream raised `coordinator_missing` on every turn from then
-  // on, and nothing could answer it: the two core operations that do had no
-  // surface at all.
-  workstream: { required: [], optional: ["session", "generation", "title", "objective",
-    "workstream"], flags: ["take", "release"] },
-  // Messages not tied to a task need a way to be answered too. Without one a
-  // `requiresAck` message raised an attention item nothing could ever clear.
-  ack: { required: ["message"], optional: ["session", "generation", "state"] },
-  // Recording what was settled, so the next session does not reopen it. The
-  // protocol has described this object from the start and nothing could make
-  // one: no command, no tool.
-  decide: { required: ["title", "outcome"],
-    optional: ["session", "generation", "authority", "workstream", "supersedes"],
-    repeated: ["decided-by"], flags: ["human"] },
-  finish: { required: ["goal"], optional: ["session", "generation", "status", "to"],
+    optional: ["session", "generation", "detail", "client-message-id"] },
+  ack: { required: ["message"], optional: ["session", "generation"] },
+  finish: { required: ["goal"], optional: ["session", "generation", "status", "to",
+    "client-message-id"],
     repeated: ["completed", "remaining", "blocker"] },
   status: { required: [], optional: ["participant"], flags: ["all"] },
   doctor: { required: [], optional: ["home"], flags: ["repair"] },
@@ -66,7 +49,8 @@ export const COMMANDS = Object.freeze({
   // `--downgrade` because an older acc first on PATH will otherwise rewire every
   // client to itself, and the only symptom is a guard behaving like the version
   // it came from.
-  install: { required: [], optional: ["adapter", "home"], flags: ["dry-run", "downgrade"] },
+  install: { required: [], optional: ["adapter", "home", "delivery"],
+    flags: ["dry-run", "downgrade"] },
   // `--dry-run` on both, because the preview was computed for either action and
   // only `install` could ask for it. Removal is the side that reaches into a
   // client's configuration - including a client that has left the machine.

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

@@ -238,6 +238,9 @@ export async function runDoctor({ options, context, runtime }) {
   // the store was healthy and nothing else.
   const text = [`store healthy; ${describePresence(status.counts)}; `
     + `protection ${status.protection}; ${installed} of ${adapters.length} adapter(s) installed`,
+  ...adapters.filter(adapter => (adapter.present || adapter.installed)
+    && typeof adapter.deliveryDiagnostic === "string")
+    .map(adapter => `  ${adapter.deliveryDiagnostic}`),
   ...data.remediation.map(line => `  ${line}`),
   // `0 of 4` is a true line that reads as a broken machine, and on an
   // MCP-only one it would read that way on every run forever. The server needs

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

@@ -13,8 +13,8 @@ import { COMMANDS } from "./args.mjs";
  */
 const GROUPS = Object.freeze([
   ["Set up", ["install", "uninstall", "doctor", "config"]],
-  ["In a session", ["status", "sync", "work", "claim", "release", "ack", "message",
-    "request", "task", "workstream", "decide", "finish"]],
+  ["In a session", ["status", "sync", "work", "claim", "release", "inbox", "reply",
+    "ack", "message", "request", "finish"]],
   ["Driven by adapters, not by people", ["attach", "heartbeat", "detach"]],
   ["About acc", ["help", "version", "update"]],
 ]);
@@ -31,10 +31,9 @@ const SUMMARY = Object.freeze({
   release: "give a claim back",
   ack: "answer a message that asked for one, so it stops asking",
   message: "send a typed message to named participants",
-  request: "ask another agent to do something: the work and the why, in one call",
-  task: "create work, --take it, or move its --state along",
-  workstream: "group related work, and steer it with --take / --release",
-  decide: "record what was settled, so the next session does not reopen it",
+  inbox: "read only unresolved messages addressed to this participant",
+  reply: "reply to one message and acknowledge it in the same operation",
+  request: "ask another agent to do something in a reply-required message",
   finish: "write the handoff and release what this session held",
   attach: "open a session; an adapter calls this, not a person",
   heartbeat: "say the session is still alive",