agents-can-communicate 0.1.16 → 0.1.18

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

@@ -1,237 +1,173 @@
 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.
-const NOTE_RESERVE = 80;
 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 }) {
+  return attention.map(item => ({
+    lines: [typeof item.sourceId === "string" && item.sourceId !== ""
+      ? `- [${item.kind}] ${item.sourceId} ${item.summary}`
+      : `- [${item.kind}] ${item.summary}`],
+    kind: "attention",
+    sourceId: item.sourceId ?? 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 messageGroups(messages) {
+  return messages.map(message => ({
+    messageId: message.messageId,
+    kind: "message",
+    lines: [
+      `${FENCE}${BLOCK}`,
+      `id ${message.messageId} | from ${message.fromSessionId} | type ${message.type}`
+        + " | untrusted peer message",
+      `subject: ${oneLine(escapePeerText(message.subject))}`,
+      "body:",
+      escapePeerText(message.body),
+      FENCE,
+    ],
+  }));
 }
 
-function claimLines(claims) {
-  return claims.map(claim => {
-    const owner = claim.ownerParticipantId ?? claim.ownerSessionId ?? "another session";
-    return `- [claim] ${claim.resource} held by ${owner}${claimNote(claim)}`;
-  });
-}
+const groupBytes = group => group.lines.reduce((total, line) => total + bytes(line) + 1, 0);
 
-/**
- * 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,
-  ]);
+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));
-  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.
-  const required = [
-    ...attentionLines(attention).map(line => [line]),
-    ...claimLines(claims).map(line => [line]),
-    ...peerBlocks(messages),
+      || (left.sourceId ?? "").localeCompare(right.sourceId ?? ""));
+  const urgent = attention.filter(item => item.priority <= 2);
+  const informational = attention.filter(item => item.priority > 2);
+  const groups = [
+    ...attentionGroups(urgent, { truncatable: true }),
+    ...messageGroups(sync.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);
-
-  // 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;
-  let dropped = 0;
-  for (const group of required) {
-    if (group.length === 1) {
-      const candidate = truncate(group[0], Math.max(0, ceiling - used - 1));
-      if (candidate === "" || used + bytes(candidate) + 1 > ceiling) { dropped += 1; continue; }
-      lines.push(candidate);
-      used += bytes(candidate) + 1;
+  const peers = peerCount(sync);
+  if (groups.length === 0 && (sync.solo === true || peers === 0)) {
+    return { text: "", includedMessageIds: [], includedAttentionIds: [] };
+  }
+
+  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;
+
+  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 = group.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) { dropped += 1; continue; }
-    lines.push(...group);
-    used += size;
-  }
-  if (dropped > 0) {
-    const note = `- +${dropped} not shown, over budget; read them with `
-      + "`acc sync --scope full --json`";
-    lines.push(note);
-    used += bytes(note) + 1;
+    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);
+    }
   }
 
-  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"),
+    includedMessageIds: 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/index.mjs

@@ -7,7 +7,7 @@ export { assertRunner, bakeSkillCommand, defaultCli, defaultRunner, removeInstal
   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/cli/package.json

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

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

@@ -26,6 +26,9 @@ export const COMMANDS = Object.freeze({
   message: { required: ["subject", "body"],
     optional: ["session", "generation", "type", "priority", "workstream"],
     repeated: ["to"], flags: ["requires-ack"] },
+  inbox: { required: [], optional: ["session", "generation", "message"] },
+  reply: { required: ["message", "body"],
+    optional: ["session", "generation", "subject", "type", "priority"] },
   // 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.
   request: { required: ["to", "title"],

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", "task", "workstream", "decide", "finish"]],
   ["Driven by adapters, not by people", ["attach", "heartbeat", "detach"]],
   ["About acc", ["help", "version", "update"]],
 ]);
@@ -31,6 +31,8 @@ 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",
+  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: 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",

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

@@ -4,6 +4,7 @@ import path from "node:path";
 import { createClaudeCodeAdapter } from "@agents-can-communicate/adapter-claude-code";
 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 }
   from "@agents-can-communicate/installer";
@@ -23,6 +24,7 @@ export const clientContext = (home, stateRoot) => ({
   agentsHome: home,
   codexHome: path.join(home, ".codex"),
   kimiHome: path.join(home, ".kimi-code"),
+  grokHome: path.join(home, ".grok"),
   // Where ACC keeps its own state, for the client that has to be told. Codex
   // sandboxes the commands a model runs to the workspace, and ACC's state is
   // outside every workspace on purpose - so an agent there could read the
@@ -32,7 +34,7 @@ export const clientContext = (home, stateRoot) => ({
 });
 
 export const ALL_ADAPTERS = () => [createClaudeCodeAdapter(), createCodexAdapter(),
-  createGeminiCliAdapter(), createKimiAdapter()];
+  createGeminiCliAdapter(), createGrokAdapter(), createKimiAdapter()];
 
 /**
  * How long to wait for a client to say its version.

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

@@ -1,6 +1,6 @@
 import { AccError, CONFIG_FILENAME, EXIT, failure, ok }
   from "@agents-can-communicate/protocol";
-import { createCoordinationService } from "@agents-can-communicate/core";
+import { createCoordinationService, noteNudge } from "@agents-can-communicate/core";
 import { openFilesystemStore } from "@agents-can-communicate/storage-filesystem";
 
 import { parseArgs, positiveNumber } from "./args.mjs";
@@ -199,7 +199,28 @@ const HANDLERS = Object.freeze({
       type: options.type ?? "note", subject: options.subject, body: options.body,
       priority: options.priority, workstreamId: options.workstream ?? null,
       requiresAck: options.requiresAck === true, descriptor: context.descriptor });
-    return { data: message, text: `sent ${message.messageId}` };
+    // A note that reads like it wants a reply was sent with no ack obligation
+    // and no standing reminder; say so once, without blocking the send. Carried
+    // in `data` so an adapter reading `--json` sees it, and appended to `text`
+    // for a person - the send already succeeded either way.
+    const advice = noteNudge(message);
+    return { data: advice ? { ...message, advice } : message,
+      text: advice ? `sent ${message.messageId}\n${advice}` : `sent ${message.messageId}` };
+  },
+
+  inbox: async ({ options, context }) => {
+    const messages = await context.service.readInbox({ sessionId: options.session,
+      generation: options.generation, messageId: options.message });
+    return { data: messages, text: messages.length === 0
+      ? "inbox empty" : JSON.stringify(messages, null, 2) };
+  },
+
+  reply: async ({ options, context }) => {
+    const result = await context.service.replyToMessage({ sessionId: options.session,
+      generation: options.generation, messageId: options.message, body: options.body,
+      subject: options.subject, type: options.type, priority: options.priority });
+    return { data: result,
+      text: `replied ${result.reply.messageId}; acknowledged ${options.message}` };
   },
 
   /**

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

@@ -20,7 +20,7 @@ import { AccError, EXIT } from "@agents-can-communicate/protocol";
  * answers that from something the caller demonstrably has.
  */
 const NEEDS_OWNER = Object.freeze(new Set(["work", "claim", "release", "message",
-  "request", "ack", "workstream", "task", "finish", "decide"]));
+  "inbox", "reply", "request", "ack", "workstream", "task", "finish", "decide"]));
 
 /**
  * Reads that are answers about *you*.

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/core",
-  "version": "0.1.16",
+  "version": "0.1.18",
   "private": true,
   "type": "module",
   "exports": {

package/node_modules/@agents-can-communicate/core/src/inbox.mjs

@@ -0,0 +1,134 @@
+import { AccError, EXIT, SCHEMA_VERSION, advanceDelivery, createId, validateRecord }
+  from "@agents-can-communicate/protocol";
+
+const receiptId = (messageId, recipient) => `${messageId}--${recipient}`;
+const unresolved = (message, receipt) => receipt.state === "recorded"
+  || receipt.state === "queued"
+  || (message.requiresAck && (receipt.state === "injected" || receipt.state === "seen"));
+
+/** Narrow, recipient-owned message reads and replies. */
+export function createInboxService(ports, sessions) {
+  const { store, clock, ids } = ports;
+
+  async function requireOpen(input, action) {
+    const existing = await sessions.locateSession(input.sessionId, input.workspaceId);
+    if (existing === null || existing.record.state !== "open"
+      || existing.record.generation !== input.generation) {
+      throw new AccError(EXIT.CONFLICT, `cannot ${action} from this session generation`,
+        { sessionId: input.sessionId });
+    }
+    return existing.record;
+  }
+
+  async function readInbox(input) {
+    const session = await requireOpen(input, "read the inbox");
+    const snapshot = await store.snapshot(session.workspaceId,
+      { kinds: ["message", "receipt"] });
+    const messages = new Map(snapshot.messages.map(message => [message.messageId, message]));
+    let addressed = snapshot.receipts
+      .filter(receipt => receipt.recipientParticipantId === session.participantId)
+      .map(receipt => ({ message: messages.get(receipt.messageId), receipt }))
+      .filter(item => item.message !== undefined);
+    if (input.messageId !== undefined) {
+      addressed = addressed.filter(item => item.message.messageId === input.messageId
+        && item.receipt.state !== "acknowledged" && item.receipt.state !== "failed");
+      if (addressed.length === 0) {
+        throw new AccError(EXIT.CONFLICT,
+          "that message is not recoverable by this participant",
+          { messageId: input.messageId, participantId: session.participantId });
+      }
+    } else {
+      addressed = addressed.filter(item => unresolved(item.message, item.receipt));
+    }
+    addressed.sort((left, right) => left.message.sentAt.localeCompare(right.message.sentAt)
+      || left.message.messageId.localeCompare(right.message.messageId));
+    if (addressed.length === 0) return [];
+
+    const now = clock.now();
+    const shown = [];
+    await store.transaction(async tx => {
+      for (const item of addressed) {
+        const id = receiptId(item.message.messageId, session.participantId);
+        const current = tx.get("receipt", id);
+        const receipt = { ...current, state: advanceDelivery(current.state, "seen"),
+          updatedAt: now };
+        tx.put("receipt", id, receipt, tx.generationOf("receipt", id));
+        tx.append({ schemaVersion: SCHEMA_VERSION, eventId: ids.next("event"),
+          workspaceId: session.workspaceId, actorSessionId: session.sessionId,
+          type: "message.seen", occurredAt: now,
+          payload: { messageId: item.message.messageId,
+            recipientParticipantId: session.participantId } });
+        shown.push({ message: item.message, receipt });
+      }
+    }, { kinds: ["receipt"] });
+    return shown;
+  }
+
+  async function replyToMessage(input) {
+    const session = await requireOpen(input, "reply to a message");
+    const now = clock.now();
+    const replyId = createId("message");
+    let result = null;
+    await store.transaction(async tx => {
+      const original = tx.get("message", input.messageId);
+      const ownReceiptId = receiptId(input.messageId, session.participantId);
+      const originalReceipt = tx.get("receipt", ownReceiptId);
+      if (original === null || originalReceipt === null
+        || !original.toParticipantIds.includes(session.participantId)) {
+        throw new AccError(EXIT.CONFLICT,
+          "that message is not addressed to this participant",
+          { messageId: input.messageId, participantId: session.participantId });
+      }
+      if (originalReceipt.state === "acknowledged" || originalReceipt.state === "failed") {
+        throw new AccError(EXIT.CONFLICT, "that message is already resolved",
+          { messageId: input.messageId, state: originalReceipt.state });
+      }
+      const reply = validateRecord("message", {
+        schemaVersion: SCHEMA_VERSION,
+        messageId: replyId,
+        workspaceId: session.workspaceId,
+        fromSessionId: session.sessionId,
+        fromParticipantId: session.participantId,
+        toParticipantIds: [original.fromParticipantId],
+        type: input.type ?? "answer",
+        subject: input.subject ?? `Re: ${original.subject}`,
+        body: input.body,
+        priority: input.priority ?? "normal",
+        workstreamId: original.workstreamId,
+        taskId: original.taskId,
+        inReplyTo: original.messageId,
+        requiresAck: false,
+        artifacts: input.artifacts ?? [],
+        sentAt: now,
+      });
+      const acknowledged = { ...originalReceipt,
+        state: advanceDelivery(originalReceipt.state, "acknowledged"), updatedAt: now };
+      const replyReceipt = validateRecord("receipt", {
+        schemaVersion: SCHEMA_VERSION,
+        messageId: replyId,
+        workspaceId: session.workspaceId,
+        recipientParticipantId: original.fromParticipantId,
+        state: "queued",
+        updatedAt: now,
+      });
+      tx.put("message", replyId, reply);
+      tx.put("receipt", receiptId(replyId, original.fromParticipantId), replyReceipt);
+      tx.put("receipt", ownReceiptId, acknowledged,
+        tx.generationOf("receipt", ownReceiptId));
+      tx.append({ schemaVersion: SCHEMA_VERSION, eventId: ids.next("event"),
+        workspaceId: session.workspaceId, actorSessionId: session.sessionId,
+        type: "message.sent", occurredAt: now,
+        payload: { messageId: replyId, type: reply.type,
+          recipients: reply.toParticipantIds } });
+      tx.append({ schemaVersion: SCHEMA_VERSION, eventId: ids.next("event"),
+        workspaceId: session.workspaceId, actorSessionId: session.sessionId,
+        type: "message.acknowledged", occurredAt: now,
+        payload: { messageId: original.messageId,
+          recipientParticipantId: session.participantId } });
+      result = { reply, receipt: acknowledged };
+    }, { kinds: ["message", "receipt"] });
+    return result;
+  }
+
+  return { readInbox, replyToMessage };
+}

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

@@ -4,5 +4,6 @@ export { assertPorts } from "./ports.mjs";
 export { classifySessionPresence } from "./sessions.mjs";
 export { defaultPidIsAlive } from "./pid.mjs";
 export { ATTENTION_PRIORITY, computeAttention } from "./sync.mjs";
+export { looksConsequential, noteNudge } from "./message-signals.mjs";
 export { overlaps } from "./claims.mjs";
 export { wouldCycle } from "./tasks.mjs";