agents-can-communicate 0.6.3 → 0.7.1

package/README.md

@@ -119,7 +119,9 @@ Automatic updates are enabled on first install. Use `acc update --auto off` to d
 [update controls](docs/UPGRADING.md) for details.
 
 MIT-licensed and permanently noncommercial. Try it on one real task and
-[tell us where you still had to carry messages yourself](https://github.com/automatis-tools/agents-can-communicate/issues).
+[tell us how it went](https://github.com/automatis-tools/agents-can-communicate/discussions/categories/show-and-tell),
+including where you still had to carry messages yourself. Bugs belong in
+[issues](https://github.com/automatis-tools/agents-can-communicate/issues).
 
 [Documentation](docs/index.md) ·
 [Contributing](https://github.com/automatis-tools/agents-can-communicate/blob/main/AGENTS.md)

package/bin/entrypoints/hook-output.mjs

@@ -38,6 +38,15 @@ function boundedDiagnostic(label, error) {
   return `${line}\n`;
 }
 
+async function releaseActivation(release) {
+  if (typeof release !== "function") return;
+  try {
+    await release();
+  } catch {
+    // The line was not delivered. Releasing its reservation is not the hook.
+  }
+}
+
 function tryWrite(stream, output) {
   if (output === "") return;
   try {
@@ -62,6 +71,9 @@ export async function completeHookOutput(result,
     await writeOutput(stdout, result.stdout ?? "", { deadlineAt: result.deadlineAt });
   } catch (error) {
     tryWrite(stderr, boundedDiagnostic("stdout write failed", error));
+    // The bytes did not cross, so a reserved activation line is not an ask.
+    // release may return nothing or throw; neither may fail this hook.
+    await releaseActivation(result.releaseActivationAsk);
     return { exitCode: 0, wroteStdout: false, committedOffers: false };
   }
 

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/CAPABILITIES.md

@@ -60,7 +60,7 @@ The limitations belong next to the adapters they affect:
 
 | Adapter | Exact limitation and evidence |
 |---|---|
-| Antigravity CLI | 1.2.7 on darwin-arm64, captured in print mode, and every later release by the forward rule. Only `SessionStart`, `PreInvocation`, `PostInvocation` and `Stop` load; `SessionEnd`, `PreToolUse` and `PostToolUse` are accepted into the config file and silently dropped, so there is no tool guard and no session-end deregistration - a session goes offline by presence age or an explicit `acc finish`. Payloads carry no `hook_event_name`, so each registered command passes its own event name. The end-of-turn `Stop` continuation reaches the model and is a bounded nudge, not a gate: ACC continues a turn at most once and fails open, and the client caps consecutive continuations itself (vendor 1.1.9). `agy agentapi send-message` can wake an idle session - captured - but only with that session's language-server address and CSRF token, which exist in the agent's own shell and in no hook. ACC does not take that token, so live push and reply routing are false. A peer message that arrives while the model writes its last answer is carried by the `Stop` continuation instead. A write that parses can register nothing, so install and doctor read `agy -p "/hooks"` back instead of trusting the file. Live push (1.2.7, darwin-arm64, TUI only, experimental, recorded opt-in) runs through a relay the agent starts once per conversation from its own shell - the only process holding the session endpoint - after ACC's context asks it to; the operator approves that command at the client's permission prompt. An idle session wakes; a busy one sees the message after its running answer, or at the next model invocation when the turn waits on a tool. Print mode and the first session in a folder trusted at that launch get no relay. |
+| Antigravity CLI | 1.2.7 on darwin-arm64, captured in print mode, and every later release by the forward rule. Only `SessionStart`, `PreInvocation`, `PostInvocation` and `Stop` load; `SessionEnd`, `PreToolUse` and `PostToolUse` are accepted into the config file and silently dropped, so there is no tool guard and no session-end deregistration - a session goes offline by presence age or an explicit `acc finish`. Payloads carry no `hook_event_name`, so each registered command passes its own event name. The end-of-turn `Stop` continuation reaches the model and is a bounded nudge, not a gate: ACC continues a turn at most once and fails open, and the client caps consecutive continuations itself (vendor 1.1.9). `agy agentapi send-message` can wake an idle session - captured - but only with that session's language-server address and CSRF token, which exist in the agent's own shell and in no hook. ACC does not take that token, so live push and reply routing are false. A peer message that arrives while the model writes its last answer is carried by the `Stop` continuation instead. A write that parses can register nothing, so install and doctor read `agy -p "/hooks"` back instead of trusting the file. Live push (1.2.7, darwin-arm64, TUI only, experimental, recorded opt-in) runs through a relay the agent starts once per conversation from its own shell - the only process holding the session endpoint - after ACC's context asks it to, up to three times while none is serving; the operator approves that command at the client's permission prompt. An idle session wakes; a busy one sees the message after its running answer, or at the next model invocation when the turn waits on a tool. Print mode and the first session in a folder trusted at that launch get no relay. |
 | Codex | Next-turn context, captured on 0.147.0, requires plugin trust. The observed stock 0.153.4 upgrade from ACC 0.3.1 to 0.4 required fresh review of five modified hook definitions; a subsequent restart retained all five active (activation evidence, not new event certification). LocalDaemon native delivery was captured through the installed package on 0.152.1 and 0.153.4, darwin-arm64; minimum 0.152.1, recorded opt-in, current feature probe and exact thread/cwd/process/version/protocol checks are required. Ordinary launch preserves the receiver workspace without ACC arguments or daemon ownership. Embedded or unreachable sessions keep their inbox. Native `replyRoute` remains false. |
 | Claude Code | 2.1.233 next-turn delivery waits for the next user prompt. A 2.1.258 Channel capture proved idle offer, busy queue-after-turn, explicit reply, duplicate suppression, and durable fallback, so `delivery.livePush` and `delivery.replyRoute` are live capabilities behind the native contract (experimental, off until opted in; Claude's development-channel warning is vendor-owned and visible). |
 | Gemini CLI | Package-shipped next-turn certification starts at 0.57.0. Its TUI has no captured external wake or queue interface and `--acp` changes launch ownership, so native delivery is fallback-only; live push and reply routing remain false. |

package/docs/CLI.md

@@ -97,10 +97,53 @@ 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.
 
+### Retention
+
+A workspace keeps what it is told to keep. `acc prune` reports what it no longer needs and
+reclaims it only when asked:
+
+```bash
+acc prune
+acc prune --apply
+acc prune --class claims --apply
+acc prune --before event_cursor
+```
+
+**`prune` changes nothing without `--apply`.** The reporting run is the default because this
+is the one command that takes records out of the store.
+
+| Class | Reclaimed when | Threshold |
+|---|---|---|
+| `sessions` | presence is `offline` | a confirmed dead pid, or 24 hours without a heartbeat |
+| `intents` | the session they belong to is reclaimed | - |
+| `claims` | the lease has expired | leases default to 30 minutes (`--lease-seconds`) |
+| `participants` | no session of theirs survives and no surviving message names them | - |
+
+`--before` takes a 16-digit cursor, the same one `sync` returns, and trims the event log to
+it. Messages recorded at or below that point go too, but only once nobody is owed them: a
+receipt that is still `queued`, `offered` or `retrieved` keeps its message, because offered is
+not read and retrieved is not model attention. A recipient that no longer exists cannot
+acknowledge anything, and does not hold a message forever.
+
+After a trim, `sync` reports `trimmedThrough`. A caller whose cursor precedes it was served a
+short page and can tell. **An ACC older than this feature cannot**: it will serve the same
+cursor without reporting the boundary, which is why trimming history is never automatic.
+
+Two classes need no operator at all. A retired transaction journal and a superseded retention
+marker have no reader, so a bounded pass reclaims them once a day when a store is opened, and
+`acc doctor --repair` reclaims them without that bound. `acc doctor` reports what is still
+held.
+
 ### Claims
 
 ```bash
@@ -221,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/GETTING_STARTED.md

@@ -146,8 +146,8 @@ until a running turn finishes. Codex requires 0.152.1 or newer, LocalDaemon infr
 recorded opt-in, and a verified session. Supported explicit setup can prepare a missing
 service. Start the client with your normal command. A loaded daemon thread can receive
 messages after its terminal exits. Antigravity CLI 1.2.7 and later has one too: with delivery enabled,
-ACC's context asks the agent once per conversation to start a relay from its own shell, and
-you approve that command at the client's prompt.
+ACC's context asks the agent to start a relay from its own shell, up to three times while
+none is running, and you approve that command at the client's prompt.
 [Capabilities](CAPABILITIES.md) explains policy, versions and fallback.
 
 Delivery evidence is deliberately narrow: `queued -> offered -> retrieved -> acknowledged`.

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/docs/TROUBLESHOOTING.md

@@ -278,9 +278,10 @@ Live delivery needs four things, and `acc doctor` shows each:
 - the live policy is on: `acc install --adapter antigravity --delivery actionable` (or `all`);
 - the session is interactive - print mode ends with its turn and never runs a relay;
 - the session attached to ACC at all (see the section above);
-- the agent started the relay. ACC's context asks once per conversation; if the command was
-  declined, or never approved at the permission prompt, nothing asks again. Ask the agent to
-  run `sh "~/.gemini/config/acc/acc-relay.sh" start`, or start a new conversation.
+- the agent started the relay. While none is running, ACC's context asks up to three times
+  in that conversation. A declined prompt and an ignored ask look the same, so the line can
+  return after a decline; after the third ask it stays quiet. Run
+  `sh "~/.gemini/config/acc/acc-relay.sh" start` to start it directly.
 
 `acc doctor` reports how many relays are running and, per session, whether a live transport is
 active. A relay ends with its client; nothing is left running after the TUI exits or after

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/adapter-antigravity",
-  "version": "0.6.3",
+  "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.6.3",
+  "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-antigravity/src/install.mjs

@@ -654,7 +654,8 @@ export async function doctorAntigravity(context) {
     diagnostics.push("registered per workspace; a session opened anywhere else loads nothing");
   }
   diagnostics.push(`live delivery starts when the agent runs sh "${relayShimPath(context.home)}" `
-    + "start once in a conversation; ACC asks it to, in its context line, when the policy is on");
+    + "start once in a conversation; while none is serving, ACC asks for that in its context "
+    + "line, up to three times, when the policy is on");
   diagnostics.push(`antigravity relays running on this machine: ${await runningRelays({
     dataHome: context.dataHome })}`);
   return { ok: true, changes: [], diagnostics };

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

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { execFile } from "node:child_process";
-import { lstat, mkdir, open } from "node:fs/promises";
+import { constants } from "node:fs";
+import { lstat, mkdir, open, rm } from "node:fs/promises";
 import net from "node:net";
 import path from "node:path";
 
@@ -144,27 +145,72 @@ export async function offerMessage({ binding, message, runtimeDir, timeoutMs = 8
   }
 }
 
+const ASK_LIMIT = 3;
 const HINT = home => "ACC: live delivery is on but not running in this conversation. To let "
   + `peers reach you while idle, run once: sh "${path.join(home, ".gemini", "config", "acc",
     "acc-relay.sh")}" start`;
 
+// Each ask is its own file, created exclusively. A counter read and then
+// rewritten lets overlapping calls all observe the same count and each return
+// a hint. An empty file at the unsuffixed hash is the old one-ask marker: it
+// is not one of these three, so it does not spend the budget. The path is a
+// reservation: the caller deletes it when the line is not delivered.
+async function claimAsk(directory, marker) {
+  try {
+    await mkdir(directory, { recursive: true, mode: 0o700 });
+  } catch {
+    return null;
+  }
+  for (let n = 1; n <= ASK_LIMIT; n += 1) {
+    const slot = `${marker}.${n}`;
+    let handle;
+    try {
+      handle = await open(slot, constants.O_WRONLY | constants.O_CREAT | constants.O_EXCL
+        | constants.O_NOFOLLOW, 0o600);
+      return slot;
+    } catch (error) {
+      if (error?.code === "EEXIST") continue;
+      return null;
+    } finally {
+      await handle?.close().catch(() => {});
+    }
+  }
+  return null;
+}
+
+function releaseAsk(slot) {
+  return rm(slot, { force: true }).catch(() => {});
+}
+
+async function relayAlreadyServing({ runtimeDir, conversationId, clientPid, isAlive }) {
+  for (const record of await listRegistrations({ runtimeDir })) {
+    if (record.conversationId !== conversationId) continue;
+    if (await serving(record, { timeoutMs: 100, isAlive, clientPid }) === null) return true;
+  }
+  return false;
+}
+
 export async function nativeActivationHint({ event, nativeBinding, runtimeDir, clientPid, env,
-  argvOf = argvDefault }) {
+  argvOf = argvDefault, isAlive = defaultAlive }) {
   // Only a degraded binding can be helped by starting a relay: "off" means the
   // live policy is off, "unsupported" that the contract does not admit this
-  // client, and "active" that a relay already serves it.
+  // client, and "active" that a relay already serves it. Those calls spend
+  // none of the asks recorded below.
   if (nativeBinding?.state !== "degraded") return null;
   const home = env?.HOME;
   if (typeof event?.sessionId !== "string" || typeof home !== "string" || home === "") return null;
   if (!Number.isInteger(clientPid) || isPrintMode(await argvOf(clientPid).catch(() => []))) return null;
+  // The runner asks only when its own handshake failed. A relay can still be
+  // serving under a stale degraded binding; telling the agent to start it again
+  // would be wrong, and the check does not spend an ask.
+  if (await relayAlreadyServing({ runtimeDir, conversationId: event.sessionId, clientPid,
+    isAlive })) return null;
   const asked = path.join(path.dirname(relayDir(runtimeDir)), "antigravity-asked");
   const marker = path.join(asked, createHash("sha256").update(event.sessionId).digest("hex"));
-  try {
-    await mkdir(asked, { recursive: true, mode: 0o700 });
-    const handle = await open(marker, "wx", 0o600);
-    await handle.close();
-  } catch {
-    return null;
-  }
-  return HINT(home);
+  // A decline and an ignored ask leave the same trace, so neither can stop the
+  // line by itself. Three exclusive creates are the bound. The file reserves
+  // the number now; release gives it back when the runner does not deliver.
+  const slot = await claimAsk(asked, marker);
+  if (slot === null) return null;
+  return { line: HINT(home), release: () => releaseAsk(slot) };
 }

package/node_modules/@agents-can-communicate/adapter-claude-code/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/adapter-claude-code",
-  "version": "0.6.3",
+  "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.6.3",
+  "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.6.3",
+  "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.6.3",
+  "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.6.3",
+  "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.6.3",
+  "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.6.3",
+  "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/adapter-sdk/src/native-attempt-writer.mjs

@@ -15,7 +15,7 @@ const checkDeadline = deadline => {
   if (Date.now() >= deadline) throw new Error("native diagnostic deadline expired");
 };
 
-// The caller stops waiting after 250 ms at most. An in-flight filesystem call
+// The caller stops waiting after 1.5 s at most. An in-flight filesystem call
 // may complete later, so retain this SEPARATE mutex until its continuation is
 // finished. Unique staging names also isolate cleanup after stale-lock recovery.
 // No diagnostic operation can touch the authoritative hook-owner file.

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

@@ -39,7 +39,9 @@ export async function loadNativeAttempt({ runtimeDir, harnessSessionId, accSessi
 // must not keep the vendor's short-lived hook process alive after its output.
 // The unreferenced worker owns its mutex through any late I/O continuation.
 async function writeDiagnostic(operation, input) {
-  const deadlineAt = Math.min(input.deadlineAt ?? Infinity, Date.now() + 250);
+  // Same ceiling as the hook runner's diagnostic budget. A caller cannot wait
+  // longer than this, and a shorter deadlineAt is still honored.
+  const deadlineAt = Math.min(input.deadlineAt ?? Infinity, Date.now() + 1_500);
   if (Date.now() >= deadlineAt) return false;
   let worker;
   let timer;

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

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

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

@@ -40,6 +40,12 @@ export const COMMANDS = Object.freeze({
     repeated: ["completed", "remaining", "blocker"] },
   status: { required: [], optional: ["session", "generation", "participant"], flags: ["all"] },
   doctor: { required: [], optional: ["home"], flags: ["repair"] },
+  // `--apply` rather than `--dry-run`: this is the one command that takes
+  // records out of the store, so the reporting run is what happens by
+  // default and meaning it is what has to be said out loud.
+  // No `--session`: this acts on the workspace, not as a participant in it, so
+  // a session id would be a credential nothing reads.
+  prune: { required: [], optional: ["before"], repeated: ["class"], flags: ["apply"] },
   // The one command with a subcommand. Kept as an explicit list rather than a
   // free positional: `acc config delete` should fail at the parser, not deep
   // inside a handler that has already decided what to do.