agents-can-communicate 0.7.0 → 0.7.1

package/docs/ARCHITECTURE.md

@@ -181,6 +181,11 @@ Adapters project peer bodies in an attributed untrusted frame. If a complete bod
 fit, the projection keeps the message id and points to `acc inbox --message <id>` instead
 of silently truncating it.
 
+On a client that takes next-turn bodies, a live offer that is still `offered` 15 minutes later
+is projected once more before a turn,
+after the new bodies and marked as a repeat, and never by an end-of-turn continuation; see
+[the protocol contract](PROTOCOL.md#one-repeat-of-a-live-offer).
+
 For this participant's unresolved messages already `offered` or `retrieved`, the standard
 projector combines reply and acknowledgement reminders into a compact count after new
 message bodies. Queued obligations and claim conflicts remain individual attention items.

package/docs/CLI.md

@@ -97,7 +97,13 @@ acc work --clear
 ```
 
 `status` returns participants, current intent, claims, protection, attention, and current
-delivery bindings. Default `sync` reads events after a 16-digit event cursor (100 by
+delivery bindings. Each session row carries its participant's `unretrieved: {queued, offered}`,
+the messages addressed to that participant that it has not fetched, split by how far delivery
+got. Two sessions of one participant show the same numbers, so read the workspace total from
+`counts.unretrieved` rather than adding rows, and the text line ends with
+`<n> offered, not retrieved` when that number is above zero. Offered is not read: a
+transport took the bytes, and the model may or may not have looked. Default `sync` reads
+events after a 16-digit event cursor (100 by
 default, up to 500). `--scope history` discovers historical message headers and reads
 selected records; `--scope full` adds an unbounded snapshot for explicit workspace forensics.
 
@@ -258,7 +264,12 @@ summary fields, ordering, page limits, and message-id cursors as inbox. `--type`
 any message kind and filters before pagination; keep the same filter between pages.
 This public workspace observation includes records from before your session joined.
 Exact history reads return `view: "message"` and one complete message in `items`,
-without changing any receipt. Do not combine `--message` with type, cursor, or limit;
+without changing any receipt, plus `receipts`: one entry per recipient with `state`,
+`updatedAt` (the last state change) and `offer` - the transport that accepted it, when, and
+`repeatedAt` if the next turn showed it again - or `offer: null` when no offer was recorded
+or an older ACC recorded it. This is how a sender tells a message a peer's client accepted
+(`offered`) from one its participant fetched (`retrieved`) or answered (`acknowledged`).
+Retrieved is not model attention either. Do not combine `--message` with type, cursor, or limit;
 message and type are valid only in history scope. Decision reads also include `decisionStatus`. Use
 `acc sync --scope history --type decision --current --json` for terminal decisions
 and withdrawals; keep these filters when paging. Exact reads cannot use `--current`.

package/docs/CONCEPTS.md

@@ -121,6 +121,13 @@ Listing inbox headers and observing workspace history do not change receipts.
 There is no `seen` receipt. A failed delivery attempt leaves the message queued and
 recoverable rather than creating a terminal failure state.
 
+The sender can see where each copy got to. An exact history read of a message lists every
+recipient's receipt with the time of its last change and the transport that offered it, and
+`acc status` counts, per participant, the messages offered and not yet retrieved. A live
+transport accepting a message is the weakest of these facts, so a live offer that nothing
+followed for 15 minutes is shown once more at the recipient's next turn, marked as a repeat,
+on a client that takes next-turn bodies.
+
 ## Durable first, faster delivery second
 
 The durable inbox is universal. An adapter whose captures reach the installed client may

package/docs/PROTOCOL.md

@@ -199,6 +199,37 @@ peer body into diagnostics.
 Receipt `offered` is committed only after the transport accepts bytes. A failed attempt
 leaves the receipt queued.
 
+The same transaction records how the receipt was offered, in the receipt's `extensions`:
+
+```json
+{ "offer": { "transport": "codex-app-server", "at": "<timestamp>", "repeatedAt": null } }
+```
+
+It lives in `extensions` because a new receipt field would fail validation in an older ACC
+that reads the same store. A receipt offered by an older ACC has no `offer` entry; readers
+report `offer: null` and never guess a transport. An exact history read returns every
+recipient's `state`, `updatedAt` and `offer` beside the message.
+
+### One repeat of a live offer
+
+A `next-turn` offer is recorded only after the hook's output carried the body, which is the
+closest ACC comes to the model. A live offer proves that a transport accepted the bytes. A
+direct message whose receipt is still `offered`, whose offer transport is anything other than
+`next-turn`, and whose offer is at least 15 minutes old, is shown once more by the
+recipient's next turn on a client that takes next-turn bodies (a certified `nextTurn` and a
+structured renderer): the body in the usual untrusted block, after new messages, with the
+line `repeat: offered via <transport> at <timestamp>; no retrieval recorded`. An end-of-turn
+continuation never carries a repeat, because continuing a turn costs a model call.
+
+When the hook's output carried it, the repeat is recorded as another
+`message.offer_succeeded` with `transport: "next-turn"` and `repeat: true`, and
+`extensions.offer.repeatedAt` is set. The receipt keeps its state and `updatedAt`: a repeat
+is an attempt, never a transition and never a second message. A repeat is recorded at most
+once per receipt, and a receipt that was retrieved, acknowledged or repeated in the meantime is
+left unchanged with nothing appended. Like a first offer, the display itself can happen twice:
+two sessions of one participant can both show it before either commits, and a hook that runs
+out of time after writing does not commit at all.
+
 `transport_permission_denied` means the sender's OS or sandbox refused local transport
 access (`EPERM` or `EACCES`). It is distinct from `recipient_unavailable` and remains a
 failed offer with a queued receipt; raw OS error strings are not persisted.

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

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

package/node_modules/@agents-can-communicate/adapter-antigravity/plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "acc",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "description": "Coordinate this Antigravity CLI session with other AI agent sessions working in the same workspace."
 }

package/node_modules/@agents-can-communicate/adapter-antigravity/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.
+
 ### Stay reachable while idle
 
 ACC can wake this conversation when a peer writes while you are idle, once its
@@ -137,6 +141,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-claude-code/package.json

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

package/node_modules/@agents-can-communicate/adapter-claude-code/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-codex/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/adapter-codex",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "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.7.1",
   "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.7.1",
   "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.7.1",
   "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.7.1",
   "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.7.1",
   "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/cli/package.json

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

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

@@ -174,6 +174,20 @@ export function describePresence({ live = 0, stale = 0 } = {}) {
   return `${live} live (${stale} not answering)`;
 }
 
+export function describeStatus(status) {
+  // `live` counts everyone present, which includes sessions gone stale - a
+  // client that exited without its session being closed keeps a record that
+  // stops being answered but does not disappear. Printing the number alone
+  // said "1 live" about a workspace where the last agent had left minutes
+  // before, which is the one thing a person reads this line to find out.
+  const line = `${describePresence(status.counts)}; ${status.counts.claims} claim(s); `
+    + `protection ${status.protection}`;
+  // A transport accepting a message is not a model reading it. Said only when
+  // it is true of something, so the everyday line stays the everyday line.
+  const offered = status.counts.unretrieved?.offered ?? 0;
+  return offered === 0 ? line : `${line}; ${offered} offered, not retrieved`;
+}
+
 const HANDLERS = Object.freeze({
   attach: async ({ options, context }) => {
     const session = await context.service.openSession({
@@ -336,14 +350,7 @@ const HANDLERS = Object.freeze({
   status: async ({ options, context }) => {
     const status = await context.service.collectStatus({
       participantId: options.participant, all: options.all === true });
-    // `live` counts everyone present, which includes sessions gone stale - a
-    // client that exited without its session being closed keeps a record that
-    // stops being answered but does not disappear. Printing the number alone
-    // said "1 live" about a workspace where the last agent had left minutes
-    // before, which is the one thing a person reads this line to find out.
-    const text = `${describePresence(status.counts)}; ${status.counts.claims} claim(s); `
-      + `protection ${status.protection}`;
-    return { data: status, text };
+    return { data: status, text: describeStatus(status) };
   },
 
   config: async ({ options, runtime }) => {

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

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

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

@@ -292,8 +292,8 @@ export function createConversationService(ports, sessions) {
     return (await nextTurnDelivery(input)).queuedMessages;
   }
 
-  function nextTurnDelivery(input) {
-    return selectNextTurnDelivery(store, input);
+  function nextTurnDelivery(input = {}) {
+    return selectNextTurnDelivery(store, { ...input, now: clock.now() });
   }
 
   return { sendMessage, finishSession, pendingMessages, nextTurnDelivery };

package/node_modules/@agents-can-communicate/core/src/next-turn-delivery.mjs

@@ -1,7 +1,10 @@
+import { decisionView, isCurrentDecision } from "./decision-state.mjs";
+import { dueForRepeat, offerFacts } from "./receipts.mjs";
+
 export async function nextTurnDelivery(store, input = {}) {
   if (typeof input.participantId !== "string" || input.participantId === "") {
     return { queuedMessages: [], liveOfferedMessageIds: [], reminderMessageIds: [],
-      roomMessageIds: [] };
+      roomMessageIds: [], repeatMessages: [], repeatOffers: [] };
   }
   const snapshot = await store.snapshot(input.workspaceId ?? store.workspaceId,
     { kinds: ["message", "receipt"] });
@@ -13,19 +16,33 @@ export async function nextTurnDelivery(store, input = {}) {
     && message.fromSessionId !== input.exceptSessionId)
     .sort((left, right) => left.sentAt.localeCompare(right.sentAt)
       || left.messageId.localeCompare(right.messageId));
+  // Only a caller that will show them asks. A repeat taken out of the reminder
+  // lists and then never shown would be the one message this turn forgot.
+  const repeatMessages = input.repeats === true
+    ? eligible.filter(message => dueForRepeat(message,
+      receiptByMessage.get(message.messageId), input.now))
+    : [];
+  const repeating = new Set(repeatMessages.map(message => message.messageId));
   return {
     queuedMessages: eligible.filter(message =>
       receiptByMessage.get(message.messageId).state === "queued"),
     liveOfferedMessageIds: eligible.filter(message => message.toParticipantIds.length > 0
-      && receiptByMessage.get(message.messageId).state === "offered")
+      && receiptByMessage.get(message.messageId).state === "offered"
+      && !repeating.has(message.messageId))
       .map(message => message.messageId),
     // A missing body is not evidence of delivery: a degraded adapter may have
     // withheld it. Only this recipient's durable receipt permits a reminder.
     reminderMessageIds: eligible.filter(message => message.obligation !== "none"
-      && ["offered", "retrieved"].includes(receiptByMessage.get(message.messageId).state))
+      && ["offered", "retrieved"].includes(receiptByMessage.get(message.messageId).state)
+      && !repeating.has(message.messageId))
       .map(message => message.messageId),
     roomMessageIds: eligible.filter(message => message.toParticipantIds.length === 0)
       .map(message => message.messageId),
+    // After the queued bodies, so a new message wins the byte budget first.
+    repeatMessages,
+    repeatOffers: repeatMessages.map(message => {
+      const { transport, at } = offerFacts(receiptByMessage.get(message.messageId));
+      return { messageId: message.messageId, transport, at };
+    }),
   };
 }
-import { decisionView, isCurrentDecision } from "./decision-state.mjs";

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

@@ -3,6 +3,42 @@ import { AccError, EXIT, SCHEMA_VERSION, advanceReceipt }
 
 import { receiptId } from "./conversations.mjs";
 
+// How long a live offer may stand with nothing after it before the next turn
+// shows the body once more. Above the 90th percentile of the time models took
+// to retrieve, acknowledge or answer an offered message on real stores.
+export const REPEAT_OFFER_AFTER_MS = 15 * 60 * 1000;
+
+/**
+ * How and when a transport accepted this receipt's message, if anyone recorded it.
+ *
+ * Kept in `extensions` because a new receipt field would fail validation in an
+ * older ACC reading the same store. A receipt that an older ACC offered carries
+ * nothing here, and reads as `null`: unknown, never guessed.
+ */
+export function offerFacts(receipt) {
+  const offer = receipt?.extensions?.offer;
+  if (offer === null || typeof offer !== "object" || Array.isArray(offer)
+    || typeof offer.transport !== "string" || typeof offer.at !== "string"
+    || !Number.isFinite(Date.parse(offer.at))) return null;
+  return { transport: offer.transport, at: offer.at,
+    repeatedAt: offer.repeatedAt == null ? null : String(offer.repeatedAt) };
+}
+
+/**
+ * A live transport accepted this message, and nothing followed for long enough.
+ *
+ * A next-turn offer is recorded only after the hook's stdout carried the body,
+ * which is as close to the model as ACC can see, so it is never repeated. A live
+ * offer proves a transport took the bytes. Once, the next turn shows it again.
+ */
+export function dueForRepeat(message, receipt, now) {
+  const offer = offerFacts(receipt);
+  return message != null && message.toParticipantIds.length > 0
+    && receipt?.state === "offered" && offer !== null
+    && offer.transport !== "next-turn" && offer.repeatedAt === null
+    && Date.parse(now) - Date.parse(offer.at) >= REPEAT_OFFER_AFTER_MS;
+}
+
 export const SAFE_OFFER_ERROR_CODES = Object.freeze([
   "ambiguous_recipient_sessions",
   "delivery_disabled",
@@ -59,28 +95,48 @@ export function createReceiptService(ports) {
   }
 
   async function recordOfferSucceeded(input) {
+    const repeat = input.repeat === true;
+    if (repeat && input.transport !== "next-turn") {
+      throw new AccError(EXIT.DATA, "a repeated offer travels only through the next turn",
+        { messageId: input.messageId, transport: input.transport });
+    }
     const now = clock.now();
     return store.transaction(tx => {
       const id = receiptId(input.messageId, input.recipientParticipantId);
       const receipt = requireOfferableReceipt(tx, input, { allowRoomNextTurn: true });
       const target = requireTarget(tx, input, { mustBeOpen: true });
+      const success = extra => tx.append({ schemaVersion: SCHEMA_VERSION,
+        eventId: ids.next("event"), workspaceId: receipt.workspaceId,
+        actorSessionId: target.sessionId, type: "message.offer_succeeded", occurredAt: now,
+        payload: { messageId: input.messageId,
+          recipientParticipantId: input.recipientParticipantId,
+          targetSessionId: input.targetSessionId,
+          targetGeneration: input.targetGeneration,
+          transport: input.transport, adapterId: input.adapterId,
+          clientVersion: input.clientVersion, ...extra } });
+      if (repeat) {
+        // Judged again under the writer: a retrieval, an acknowledgement or
+        // another hook's repeat may have landed since this one was selected.
+        // The receipt keeps its state and its time; only the attempt is new.
+        if (!dueForRepeat(tx.get("message", input.messageId), receipt, now)) return receipt;
+        // Spread from the stored object, never from offerFacts: a later ACC
+        // may keep more about an offer, and this write must not drop it.
+        const repeated = { ...receipt, extensions: { ...receipt.extensions,
+          offer: { ...receipt.extensions.offer, repeatedAt: now } } };
+        tx.put("receipt", id, repeated, tx.generationOf("receipt", id));
+        success({ repeat: true });
+        return repeated;
+      }
       // A retrieval or acknowledgement may win after a transport accepted but
       // before this transaction acquired the writer. That stronger truth must
       // remain in place. The same rule makes a repeated successful commit a
       // read-only operation rather than another success event.
       if (receipt.state !== "queued") return receipt;
       const offered = { ...receipt, state: advanceReceipt(receipt.state, "offered"),
-        updatedAt: now };
+        updatedAt: now, extensions: { ...receipt.extensions,
+          offer: { transport: input.transport, at: now, repeatedAt: null } } };
       tx.put("receipt", id, offered, tx.generationOf("receipt", id));
-      tx.append({ schemaVersion: SCHEMA_VERSION, eventId: ids.next("event"),
-        workspaceId: receipt.workspaceId, actorSessionId: target.sessionId,
-        type: "message.offer_succeeded", occurredAt: now,
-        payload: { messageId: input.messageId,
-          recipientParticipantId: input.recipientParticipantId,
-          targetSessionId: input.targetSessionId,
-          targetGeneration: input.targetGeneration,
-          transport: input.transport, adapterId: input.adapterId,
-          clientVersion: input.clientVersion } });
+      success({});
       return offered;
     }, { kinds: ["session", "message", "receipt"], deadlineAt: input.deadlineAt });
   }

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

@@ -1,6 +1,7 @@
 import { classifySessionPresence } from "./sessions.mjs";
 import { computeAttention } from "./attention.mjs";
 import { isCurrentIntent } from "./intents.mjs";
+import { decisionView, isCurrentDecision } from "./decision-state.mjs";
 
 /**
  * Protection level, reported from what is actually enforceable.
@@ -87,6 +88,22 @@ export function createStatusService(ports, sessions, deliveryBindings) {
     const claims = snapshot.claims
       .filter(claim => Date.parse(claim.expiresAt) > Date.parse(now));
     const currentBindings = await deliveryBindings.currentBindings(now);
+    // What each recipient has not fetched yet, and how far it got. Offered is
+    // not read: a transport took the bytes. Queued sits beside it so "0
+    // offered" cannot be mistaken for "nothing waits". Replaced decisions
+    // leave these counts exactly as they leave the inbox.
+    const current = new Set(snapshot.messages.map(decisionView(snapshot.messages))
+      .filter(isCurrentDecision).map(message => message.messageId));
+    const unretrieved = new Map();
+    const tally = key => unretrieved.get(key) ?? { queued: 0, offered: 0 };
+    for (const receipt of snapshot.receipts) {
+      if (!current.has(receipt.messageId)
+        || !["queued", "offered"].includes(receipt.state)) continue;
+      for (const key of [receipt.recipientParticipantId, null]) {
+        const counts = tally(key);
+        unretrieved.set(key, { ...counts, [receipt.state]: counts[receipt.state] + 1 });
+      }
+    }
 
     return {
       workspaceId,
@@ -114,6 +131,7 @@ export function createStatusService(ports, sessions, deliveryBindings) {
         // a done record made the command and this line contradict each other.
         intent: intents.find(intent => intent.sessionId === session.sessionId
           && isCurrentIntent(intent))?.summary ?? null,
+        unretrieved: tally(session.participantId),
       })),
       // The owner is named twice on purpose. Every command that reaches a peer
       // takes a participant id, so a claim that gave only a session id sent the
@@ -148,6 +166,7 @@ export function createStatusService(ports, sessions, deliveryBindings) {
         stale: live.filter(item => item.presence === "stale").length,
         claims: claims.length,
         messages: snapshot.messages.length,
+        unretrieved: tally(null),
       },
     };
   }

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

@@ -4,6 +4,7 @@ import { computeAttention } from "./attention.mjs";
 import { classifySessionPresence } from "./sessions.mjs";
 import { assertMessageId, messagePage } from "./message-pages.mjs";
 import { decisionView, isCurrentDecision } from "./decision-state.mjs";
+import { offerFacts } from "./receipts.mjs";
 
 const DEFAULT_LIMIT = 100;
 const CURSOR = /^[0-9]{16}$/;
@@ -38,7 +39,7 @@ export function createSyncService(ports, sessions) {
     }
     if (exact) assertMessageId(input.messageId);
     const snapshot = await store.snapshot(input.workspaceId ?? store.workspaceId,
-      { kinds: ["message"] });
+      { kinds: exact ? ["message", "receipt"] : ["message"] });
     const messages = snapshot.messages.map(decisionView(snapshot.messages));
     if (!exact) return messagePage(messages, input,
       { include: message => input.current !== true || isCurrentDecision(message),
@@ -47,7 +48,15 @@ export function createSyncService(ports, sessions) {
     if (message === undefined) {
       throw new AccError(EXIT.DATA, "message is not in this workspace's history");
     }
-    return { scope: "history", view: "message", items: [message], nextCursor: null };
+    // Beside the message rather than inside it: the router offers `items[0]`
+    // to a transport, and a sender asking "did they get it" wants every
+    // recipient's answer. `sync --scope full` already shows all of it.
+    const receipts = snapshot.receipts
+      .filter(receipt => receipt.messageId === message.messageId)
+      .sort((left, right) => left.recipientParticipantId.localeCompare(right.recipientParticipantId))
+      .map(receipt => ({ recipientParticipantId: receipt.recipientParticipantId,
+        state: receipt.state, updatedAt: receipt.updatedAt, offer: offerFacts(receipt) }));
+    return { scope: "history", view: "message", items: [message], receipts, nextCursor: null };
   }
 
   async function sync(input = {}) {

package/node_modules/@agents-can-communicate/delivery-router/package.json

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

package/node_modules/@agents-can-communicate/hook-runner/package.json

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

package/node_modules/@agents-can-communicate/hook-runner/src/runner.mjs

@@ -237,7 +237,7 @@ async function openContext({ event, adapterId, dataHome, runtime, env, deadline
 // `render` is how the projected text reaches this client: before a turn it is
 // the adapter's context envelope, at the end of one it is a continuation.
 async function projectTurn({ binding, context, adapter, adapterId,
-  render = text => adapter.injectOutcome?.(text), activationHint = null }) {
+  render = text => adapter.injectOutcome?.(text), activationHint = null, repeats = true }) {
   const sync = await context.service.sync({ sessionId: binding.accSessionId,
     cursor: null, scope: "delta" });
 
@@ -251,11 +251,22 @@ async function projectTurn({ binding, context, adapter, adapterId,
   // Without this the projector's peer block never runs in production: an
   // agent sees only the obligation attention line, not the durable body that
   // may be offered after the stdout transport succeeds.
+  // Decided before selection: a repeat is taken out of the reminder lists, so
+  // asking for one this turn cannot show is how a message would go quiet.
+  // The ceiling a team agreed on in `acc.workspace.json`, or the default when
+  // there is no config. Validated by the protocol and, until now, never read:
+  // the projector was always called with its own default.
+  const effective = effectiveCapabilities(adapter, binding);
+  const hasStructuredRenderer = typeof adapter.renderContextResult === "function";
+  const canOfferNextTurn = effective.delivery.nextTurn === true && hasStructuredRenderer;
   const delivery = await context.service.nextTurnDelivery({
     workspaceId: context.descriptor.id,
     participantId: mine?.participantId,
-    exceptSessionId: binding.accSessionId });
-  const messages = delivery.queuedMessages;
+    exceptSessionId: binding.accSessionId,
+    repeats: repeats && canOfferNextTurn });
+  // New bodies first, so a repeat is what the byte budget drops.
+  const messages = [...delivery.queuedMessages, ...delivery.repeatMessages];
+  const repeating = new Set(delivery.repeatMessages.map(message => message.messageId));
 
   // Only this hook's payload selected the binding. Supply its own pair as
   // trusted context, outside peer bodies, rather than exporting inheritable
@@ -278,16 +289,11 @@ async function projectTurn({ binding, context, adapter, adapterId,
       hintFits);
   }
 
-  // The ceiling a team agreed on in `acc.workspace.json`, or the default when
-  // there is no config. Validated by the protocol and, until now, never read:
-  // the projector was always called with its own default.
-  const effective = effectiveCapabilities(adapter, binding);
-  const hasStructuredRenderer = typeof adapter.renderContextResult === "function";
-  const canOfferNextTurn = effective.delivery.nextTurn === true && hasStructuredRenderer;
   const projectionInput = { ...sync, messages: canOfferNextTurn ? messages : [],
     liveOfferedMessageIds: delivery.liveOfferedMessageIds,
     reminderMessageIds: delivery.reminderMessageIds,
     roomMessageIds: delivery.roomMessageIds,
+    repeatOffers: delivery.repeatOffers,
     currentParticipantId: mine?.participantId };
   // Credentials alone cannot replace the command that reaches a queued body.
   // If both cannot fit, preserve recovery and explain the missing owner pair.
@@ -346,7 +352,8 @@ async function projectTurn({ binding, context, adapter, adapterId,
       recipientParticipantId: mine.participantId,
       targetSessionId: binding.accSessionId, targetGeneration: binding.generation,
       transport: "next-turn", adapterId,
-      clientVersion: binding.clientVersion }));
+      clientVersion: binding.clientVersion,
+      ...(repeating.has(message.messageId) ? { repeat: true } : {}) }));
   // Same again: Kimi Code shows the model a hook's raw stdout, while Gemini
   // and Claude Code want an envelope and drop a bare string.
   // The entry point owns the transport boundary. This handler only prepares
@@ -583,7 +590,9 @@ const HANDLERS = {
     const current = await context.service.locateSession(binding.accSessionId);
     if (current === null || current.record.state !== "open"
       || current.record.generation !== binding.generation) return {};
-    const turn = await projectTurn({ ...input,
+    // A repeat is a body the model may already have. It rides on the next
+    // turn that happens anyway and never buys a model call of its own.
+    const turn = await projectTurn({ ...input, repeats: false,
       render: text => adapter.continueTurnOutcome({ reason: text, payload }) });
     return (turn.offerInputs ?? []).length === 0 ? {} : turn;
   },

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

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

package/node_modules/@agents-can-communicate/mcp-server/package.json

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

package/node_modules/@agents-can-communicate/mcp-server/src/tools.mjs

@@ -23,15 +23,17 @@ const stringList = description => ({ type: "array", items: { type: "string" }, d
 export const PUBLIC_TOOLS = Object.freeze([
   {
     name: "acc_status",
-    description: `Read who is here, current intents and claims, and the workspace's real `
-      + `protection level. ${POLLED}`,
+    description: `Read who is here, current intents and claims, the workspace's real `
+      + `protection level, and how many messages each participant has not fetched `
+      + `(offered is not read). ${POLLED}`,
     inputSchema: object({}),
   },
   {
     name: "acc_sync",
     description: `Read coordination state for this workspace: roster, attention items, and `
       + `events since a cursor. Use scope "history" for bounded message summaries, then `
-      + `messageId to read one complete historical message without changing receipts. `
+      + `messageId to read one complete historical message, with every recipient's `
+      + `receipt state, without changing receipts. `
       + `Scope "full" is an unbounded forensic workspace snapshot. Use acc_inbox for `
       + `your addressed messages. ${POLLED}`,
     inputSchema: object({

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

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

package/node_modules/@agents-can-communicate/storage-filesystem/package.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-can-communicate",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "accManagedUpdateProtocol": 2,
   "accStoreVersion": 6,
   "type": "module",