agents-can-communicate 0.7.0 → 0.8.0

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

@@ -2,7 +2,7 @@ import { mkdir, readdir, readFile, stat, writeFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import path from "node:path";
 
-import { describeDeliveryFallback, detectInstallation, livePolicyOf, loadOwnership, shellOf, verifyOwned }
+import { describeDeliveryFallback, detectInstallation, livePolicyOf, loadOwnership, verifyOwned }
   from "@agents-can-communicate/installer";
 import { AccError, EXIT } from "@agents-can-communicate/protocol";
 
@@ -114,12 +114,9 @@ export async function diagnoseAdapters({ options, runtime, detect = detectInstal
   const home = options?.home ?? runtime?.env?.HOME ?? homedir();
   const { data: dataHome } = platformPaths({ platform: runtime?.platform,
     env: runtime?.env ?? {} });
-  // The same shell and environment install reads, so detection plans the same
-  // shell bootstrap it would apply. Omitting them left detection with a null
-  // shell, which degrades every shell-bootstrap client to `unsupported_shell` -
-  // so a zsh machine with a working shim read as degraded on every run.
+  // The same environment install reads, so detection probes the same client.
   const clients = clientContext(home, path.join(dataHome, "acc"),
-    { shell: shellOf(runtime?.env ?? {}), env: runtime?.env ?? {} });
+    { env: runtime?.env ?? {} });
   const adapters = ALL_ADAPTERS();
   const detected = await detect({ adapters, context: clients,
     probeTimeoutMs: probeTimeout(runtime?.env) });
@@ -297,6 +294,11 @@ export async function runDoctor({ options, context, runtime }) {
   ...nativeSessionLines(adapters),
   ...adapters.filter(adapter => adapter.present && adapter.outgoingDelivery?.state === "configured")
     .map(adapter => `  ${adapter.displayName} ${adapter.outgoingDelivery.diagnostic}`),
+  // The client's own inbound control decides whether a wake reaches the model.
+  // Only someone who turned live delivery on needs to hear about it.
+  ...adapters.filter(adapter => adapter.present && adapter.nativeDelivery.configured
+    && typeof adapter.inboundDelivery?.diagnostic === "string")
+    .map(adapter => `  ${adapter.displayName} inbound: ${adapter.inboundDelivery.diagnostic}`),
   ...(manager === null ? [] : [`  automatic updates ${manager.auto ? "on" : "off"}; ACC ${manager.active.version}`
     + (manager.pin ? `; pinned to ${manager.pin}` : ""), ...(update.notice ? [`  ${update.notice}`] : [])]),
   ...data.remediation.map(line => `  ${line}`),

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

@@ -7,8 +7,7 @@ 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, rcFileFor, shellOf, shimDirFor }
+import { applyPlan, detectInstallation, loadOwnership, planInstallation }
   from "@agents-can-communicate/installer";
 import { AccError, EXIT } from "@agents-can-communicate/protocol";
 
@@ -29,7 +28,7 @@ export { decideDelivery } from "./install-delivery-consent.mjs";
 // pointed at the home itself writes beside them rather than inside them. That
 // install reports success and the client never reads a byte of it.
 export const clientContext = (home, stateRoot,
-  { shell = null, env = {}, dataHome, cwd = process.cwd() } = {}) => ({
+  { env = {}, dataHome, cwd = process.cwd() } = {}) => ({
   home,
   ...(dataHome === undefined ? {} : { dataHome }),
   configDir: path.join(home, ".claude"),
@@ -39,10 +38,8 @@ export const clientContext = (home, stateRoot,
   kimiHome: path.join(home, ".kimi-code"),
   grokHome: typeof env.GROK_HOME === "string" && env.GROK_HOME !== ""
     ? env.GROK_HOME : path.join(home, ".grok"),
-  // The user's login shell and PATH, for the optional native shell bootstrap:
-  // which rc file could carry an ACC PATH block and which real executable a
-  // shim would exec. Detection reads them; nothing here writes.
-  shell,
+  // The user's PATH, for finding the real client executable to probe.
+  // Detection reads it; nothing here writes.
   env,
   // Antigravity CLI keeps its hooks in the `~/.gemini` tree Gemini CLI also
   // uses, and reads none of the same files. Two locations load - the
@@ -200,8 +197,7 @@ export function describeOutcome({ action, acted, failed = [], skipped = [],
 export function failureOf({ action, acted, failed = [], operations = [], skipped = [], home }) {
   if (failed.length === 0) return null;
   return new AccError(EXIT.DATA,
-    [describeOutcome({ action, acted, failed, operations, skipped, home }),
-      ...reloadAdvice(operations)].join("\n"), { failed });
+    describeOutcome({ action, acted, failed, operations, skipped, home }), { failed });
 }
 
 /**
@@ -220,23 +216,13 @@ export function actedOn(result) {
         + (operation.changes?.length ?? 0) > 0)).length;
 }
 
-// Said once, after the first PATH block is written: a running shell and a
-// running client know nothing about it.
-function reloadAdvice(operations) {
-  const appended = operations.filter(operation => operation.appendedRcBlock === true);
-  if (appended.length === 0) return [];
-  const rc = appended[0].nativeActivation?.rcFile ?? "your shell rc file";
-  return ["", `native delivery is wired for new sessions: open a new terminal (or reload ${rc}), `
-    + "then start the client normally; a session already running keeps durable delivery"];
-}
-
 export async function runInstallCommand({ options, runtime, action = "install" }) {
   const adapters = selectAdapters(options.adapter);
   const home = options.home ?? runtime.env?.HOME ?? homedir();
   const { data: dataHome } = platformPaths({ platform: runtime.platform,
     env: runtime.env ?? {} });
   const context = clientContext(home, path.join(dataHome, "acc"),
-    { shell: shellOf(runtime.env), env: runtime.env ?? {}, dataHome });
+    { env: runtime.env ?? {}, dataHome });
 
   const detected = await detectInstallation({ adapters, context,
     probeTimeoutMs: probeTimeout(runtime.env) });
@@ -273,7 +259,7 @@ export async function runInstallCommand({ options, runtime, action = "install" }
     deliveryDecisionByAdapter: decided.deliveryDecisionByAdapter,
     allowServiceSetup: action === "install" });
   const apply = (paths = {}) => applyPlan({ plan, adapters, context: { ...context, ...paths },
-    dataHome, dryRun, accVersion, activation: { bootstrap: paths.bootstrap } });
+    dataHome, dryRun, accVersion });
   const result = action === "install" && !dryRun && runtime.packageRoot
     ? await installManaged({ packageRoot: runtime.packageRoot,
       managerRoot: path.join(dataHome, "acc", "runtime"), dataHome, home, cwd: options.cwd ?? runtime.cwd,
@@ -293,9 +279,8 @@ export async function runInstallCommand({ options, runtime, action = "install" }
 
   return { data: { ...result, plan, dataHome, deliveryByAdapter: decided.deliveryByAdapter,
     deliveryDecisionByAdapter: decided.deliveryDecisionByAdapter, asked: decided.asked },
-  text: [describeOutcome({ action, acted, failed: result.failed,
+  text: describeOutcome({ action, acted, failed: result.failed,
     skipped: plan.skipped, operations: result.operations, home }),
-  ...reloadAdvice(result.operations)].join("\n"),
   error: failureOf({ action, acted, failed: result.failed, operations: result.operations,
     skipped: plan.skipped, home }) };
 }

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

@@ -57,9 +57,6 @@ function questionFor(entries) {
   const names = entries.map(entry => entry.displayName ?? entry.adapterId).join(", ");
   const setup = [...new Set(entries.map(entry => entry.outgoingDelivery?.setup)
     .filter(value => typeof value === "string"))];
-  const channels = entries.some(entry => (entry.nativeDelivery?.activationPlan?.mechanisms ?? [])
-    .some(mechanism => mechanism.kind === "shell-bootstrap"
-      && (mechanism.prefixArgs ?? []).some(argument => argument.startsWith("--"))));
   return [
     `Complete automatic peer-request setup for ${names}? (experimental)`,
     "  Yes: automatic turns can spend tokens without waiting for you.",
@@ -69,7 +66,9 @@ function questionFor(entries) {
     ...entries.filter(needsPrerequisite).map(entry =>
       `       Download the official Codex ${entry.nativeServiceSetup.cliVersion} standalone package for its service; retain your existing codex command.`),
     ...setup.map(note => `       ${note}`),
-    ...(channels ? ["       Allow Claude Code development Channels when prompted at startup."] : []),
+    ...(entries.some(entry => entry.adapterId === "claude_code")
+      ? ["       Claude Code sessions that bypass permission prompts ask before each ACC wake;",
+        "       set Claude Code's crossSessionInbound to accept to take wakes without asking."] : []),
     "  No: keep current delivery policies and use available next-turn hooks or acc inbox.",
   ].join("\n");
 }

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

@@ -138,13 +138,26 @@ function obligationFor(kind, explicit, addressed) {
   return obligation;
 }
 
-function recordedText(message, delivery) {
+export function recordedText(message, delivery) {
   const diagnostics = delivery.map(item => item.outcome === "offered"
     ? `live offered to ${item.recipientParticipantId} via ${item.transport}`
+    : item.outcome === "woken" && item.pendingApproval === true
+      ? `sent a wake to ${item.recipientParticipantId} via ${item.transport}, which its session holds `
+        + "for approval because it bypasses permission prompts; the message arrives with its next turn"
+    : item.outcome === "woken"
+      ? `woke ${item.recipientParticipantId} via ${item.transport}; the message arrives with its next turn`
     : item.outcome === "queued"
       ? item.errorCode === "transport_permission_denied"
         ? "live offer blocked by sender permissions; message remains queued; run acc doctor in the sending session"
-        : `live offer unavailable (${item.errorCode ?? "durable_fallback"})`
+        : item.errorCode === "no_live_transport"
+          ? `${item.recipientParticipantId} has no live transport; the message waits in its inbox`
+        : item.errorCode === "recipient_offline" && item.endReason === "clear"
+          ? `${item.recipientParticipantId}'s conversation was cleared (/clear); the message waits `
+            + "until that conversation resumes"
+        : item.errorCode === "recipient_offline"
+          ? `${item.recipientParticipantId} has no open session; the message waits until it starts `
+            + "or resumes one"
+          : `live offer unavailable (${item.errorCode ?? "durable_fallback"})`
       : `delivery already ${item.outcome}`);
   return [`recorded ${message.messageId}`, ...diagnostics].join("; ");
 }
@@ -174,6 +187,29 @@ 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;
+  const withOffers = offered === 0 ? line : `${line}; ${offered} offered, not retrieved`;
+  // Status lists a participant with no open session only while messages wait
+  // for it; each is named here, with the client's reason when it gave one.
+  const waiting = (status.participants ?? []).filter(item => item.presence === "offline")
+    .map(item => {
+      const count = (item.unretrieved?.queued ?? 0) + (item.unretrieved?.offered ?? 0);
+      return `${item.participantId} (${item.endReason === "clear" ? "cleared, " : ""}${count})`;
+    });
+  return waiting.length === 0 ? withOffers
+    : `${withOffers}; waiting for a closed session: ${waiting.join(", ")}`;
+}
+
 const HANDLERS = Object.freeze({
   attach: async ({ options, context }) => {
     const session = await context.service.openSession({
@@ -336,14 +372,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/cli/src/managed-runtime/entry.mjs

@@ -7,24 +7,13 @@ import { canonicalManagerRoot, readControl, readManagedJson } from "./state.mjs"
 import { commandPrefix } from "./command-prefix.mjs";
 
 export const ENTRY_KINDS = Object.freeze([
-  "acc", "acc-hook", "acc-mcp", "acc-bootstrap", "acc-claude-channel", "acc-antigravity-relay",
+  "acc", "acc-hook", "acc-mcp", "acc-antigravity-relay",
 ]);
 
-const BOOTSTRAP_FLAGS = new Map([["--adapter", "adapter"], ["--real-executable", "realExecutable"],
-  ["--data-home", "dataHome"]]);
-
-/** Shared with the runtime; parse before admission without importing installer code. */
-export function parseBootstrapOptions(args) {
-  const options = {};
-  for (let index = 0; index < args.length; index += 2) {
-    const key = BOOTSTRAP_FLAGS.get(args[index]);
-    const value = args[index + 1];
-    if (key === undefined || typeof value !== "string" || value === "" || key in options) return null;
-    options[key] = value;
-  }
-  return BOOTSTRAP_FLAGS.values().every(key => key in options) && path.isAbsolute(options.dataHome)
-    ? options : null;
-}
+// Kinds a 0.7.x install wrote a launcher for. The package still ships their
+// entrypoints for 0.7.x updaters and launchers; a current install removes the
+// launchers themselves.
+export const RETIRED_ENTRY_KINDS = Object.freeze(["acc-bootstrap", "acc-claude-channel"]);
 
 // Bootstrap resolution deliberately needs only Node built-ins: no selected
 // generation is imported until admission and its actual PID lease are durable.
@@ -43,11 +32,9 @@ export function invokedDirectly(url) {
 
 function unavailable(kind) {
   // Never reflect control file content or payloads into a client diagnostic.
-  if (kind === "acc-hook" || kind === "acc-claude-channel" || kind === "acc-antigravity-relay") {
+  if (kind === "acc-hook" || kind === "acc-antigravity-relay") {
     process.stderr.write("acc: coordination unavailable during runtime update; session may continue\n");
     process.exitCode = 0;
-  } else if (kind === "acc-bootstrap") {
-    process.exitCode = 1; // The vendor shell shim launches its original command.
   } else {
     process.stderr.write("acc: runtime unavailable; retry after the update or run acc update to recover\n");
     process.exitCode = 4;
@@ -83,28 +70,12 @@ async function updateImplementation(packageRoot, control) {
 export async function runEntry({ kind, packageRoot, managerRoot, managedRequired = false }) {
   if (!ENTRY_KINDS.includes(kind)) throw new Error("unknown ACC entry point");
   const command = kind === "acc" ? commandPrefix(process.argv.slice(2)).command : null;
-  const bootstrapOptions = kind === "acc-bootstrap" ? parseBootstrapOptions(process.argv.slice(2)) : null;
-  if (kind === "acc-bootstrap" && bootstrapOptions === null) {
-    if (process.env.ACC_BOOTSTRAP_DEBUG === "1") {
-      process.stderr.write("acc-bootstrap: usage: --adapter <id> --real-executable <path> --data-home <path>\n");
-    }
-    process.exitCode = 2;
-    return;
-  }
   let selected = packageRoot;
   let managed = null;
   let managementOnly = false;
   let root;
   try {
-    const requestedDataHome = bootstrapOptions === null ? null : await canonicalManagerRoot(bootstrapOptions.dataHome);
-    const requestedRoot = requestedDataHome === null ? null
-      : await canonicalManagerRoot(path.join(requestedDataHome, "acc", "runtime"));
-    if (managerRoot && requestedDataHome !== null
-      && requestedDataHome !== await canonicalManagerRoot(path.dirname(path.dirname(managerRoot)))) {
-      throw new Error("bootstrap cache home differs from its launcher");
-    }
-    root = await canonicalManagerRoot(managerRoot ?? requestedRoot ?? managerLocation());
-    if (requestedRoot !== null && root !== requestedRoot) throw new Error("bootstrap data home differs from its launcher");
+    root = await canonicalManagerRoot(managerRoot ?? managerLocation());
     const control = await readControl(root);
     if (control !== null) {
       selected = control.active.root;
@@ -138,13 +109,6 @@ export async function runEntry({ kind, packageRoot, managerRoot, managedRequired
       } catch { /* Fall through to the same graceful unavailability below. */ }
     }
     unavailable(kind);
-    if (kind === "acc-claude-channel" && selected) {
-      try {
-        const { startInertChannel } = await import(pathToFileURL(path.join(selected,
-          "bin", "entrypoints", "claude-channel-stdio.mjs")).href);
-        startInertChannel();
-      } catch { /* The stderr notice above already fired either way. */ }
-    }
     return;
   }
   const runtime = await import(pathToFileURL(path.join(selected, "bin", "entrypoints", `${kind}.mjs`)).href);

package/node_modules/@agents-can-communicate/cli/src/managed-runtime/launchers.mjs

@@ -1,7 +1,7 @@
 import { createHash, randomUUID } from "node:crypto";
 import { lstat, mkdtemp, open, readFile, rename, rm } from "node:fs/promises";
 import path from "node:path";
-import { ENTRY_KINDS } from "./entry.mjs";
+import { ENTRY_KINDS, RETIRED_ENTRY_KINDS } from "./entry.mjs";
 import { managedDirectory, syncDirectory } from "./state.mjs";
 
 const MODULES = ["entry.mjs", "command-prefix.mjs", "state.mjs", "generation-files.mjs",
@@ -14,8 +14,6 @@ async function durableFile(file, bytes, mode = 0o600) {
 
 export const stablePaths = root => ({
   cli: path.join(root, "bin", "acc.mjs"), runner: path.join(root, "bin", "acc-hook.mjs"),
-  bootstrap: path.join(root, "bin", "acc-bootstrap.mjs"),
-  channel: path.join(root, "bin", "acc-claude-channel.mjs"),
   antigravityRelay: path.join(root, "bin", "acc-antigravity-relay.mjs"),
 });
 
@@ -57,6 +55,10 @@ export async function writeLaunchers(root, packageRoot) {
       await rename(temporary, path.join(bin, `${kind}.mjs`));
     } finally { await rm(temporary, { force: true }); }
   }
+  // A 0.7.x `claude` shim or plugin copy that still reaches for one of these
+  // finds nothing: the shim then launches the vendor command untouched, and a
+  // re-laid plugin names none of them.
+  for (const kind of RETIRED_ENTRY_KINDS) await rm(path.join(bin, `${kind}.mjs`), { force: true });
   await syncDirectory(bin);
   return stablePaths(root);
 }

package/node_modules/@agents-can-communicate/cli/src/managed-runtime/refresh.mjs

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { applyPlan, detectInstallation, livePolicyOf, loadOwnership, planInstallation, shellOf }
+import { applyPlan, detectInstallation, livePolicyOf, loadOwnership, planInstallation }
   from "@agents-can-communicate/installer";
 import { ALL_ADAPTERS, clientContext, probeTimeout } from "../install-command.mjs";
 import { stablePaths, writeLaunchers } from "./launchers.mjs";
@@ -17,7 +17,7 @@ export async function prepareRefresh({ control, root, env = process.env, callerP
   // session open across the update keeps running from the outgoing copy until it
   // restarts. Naming it here keeps that copy; everything older than it goes.
   const context = { ...clientContext(control.home, path.join(dataHome, "acc"),
-    { env, shell: shellOf(env), dataHome }), ...stablePaths(root),
+    { env, dataHome }), ...stablePaths(root),
   keepPreviousVersion: control.active.version };
   const recorded = (await loadOwnership({ dataHome })).installs;
   const detected = await detectInstallation({ adapters, context, probeTimeoutMs: probeTimeout(env) });
@@ -38,8 +38,7 @@ export async function prepareRefresh({ control, root, env = process.env, callerP
   }
   return async () => {
     await writeLaunchers(root, control.pending.root);
-    const result = await applyPlan({ plan, adapters, context, dataHome, accVersion: control.pending.version,
-      activation: { bootstrap: context.bootstrap } });
+    const result = await applyPlan({ plan, adapters, context, dataHome, accVersion: control.pending.version });
     return { ...result, failed: result.failed.map(failure => ({ ...failure,
       paths: plan.operations.find(operation => operation.adapterId === failure.adapterId)
         ?.artifacts?.map(artifact => artifact.path).filter(file => typeof file === "string") ?? [],

package/node_modules/@agents-can-communicate/cli/src/native-delivery-status.mjs

@@ -34,11 +34,11 @@ export function nativeRemediation(entry) {
       + "  # opt in to automatic peer requests; may spend tokens");
   } else if (native.configured && native.activation === "missing") {
     steps.push(`acc install --adapter ${entry.adapterId}`
-      + "  # complete the missing native launch setup from a supported shell");
+      + "  # complete the missing native delivery setup");
   } else if (native.configured && native.runtime !== "active"
     && !["needed", "blocked", "unsupported"].includes(service?.state)) {
     steps.push(`${entry.displayName}: no verified live channel in this workspace; `
-      + "open a new terminal, start a new client session and check its integration/channel prompts; "
+      + "start a new client session and check its integration prompts; "
       + "then run acc doctor here");
   }
   if (native.reasonCode === "native_endpoint_unavailable") {

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/core",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "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/sessions.mjs

@@ -33,6 +33,9 @@ const ageBand = (session, age) =>
  * @returns {"online" | "stale" | "offline"}
  * @throws {AccError} EXIT.USAGE when pidIsAlive is not a function.
  */
+// A client's end reason is a short word of its own ("clear", "logout").
+const END_REASON = /^[a-z][a-z0-9_-]{0,63}$/;
+
 export function classifySessionPresence(session, now, pidIsAlive) {
   // Required rather than defaulted. A probe that defaults to "everyone is
   // alive" turns a forgotten call site into a check that silently passes, which
@@ -149,10 +152,14 @@ export function createSessionService(ports) {
     }, { kinds: ["session"] });
   }
 
-  async function closeSession({ sessionId, workspaceId, generation }) {
+  async function closeSession({ sessionId, workspaceId, generation, endReason = null }) {
+    // The client's own word for why, kept in extensions: an older ACC reading
+    // the same store skips them, and the session.closed event is unchanged.
+    const reason = typeof endReason === "string" && END_REASON.test(endReason) ? endReason : null;
     const close = current => {
       assertGeneration({ record: current }, generation, "close", workspaceId ?? store.workspaceId);
-      return { ...current, state: "closed", heartbeatAt: clock.now() };
+      return { ...current, state: "closed", heartbeatAt: clock.now(),
+        ...(reason === null ? {} : { extensions: { ...(current.extensions ?? {}), endReason: reason } }) };
     };
     let ephemeral = null;
     await store.ephemeral.delete("session", sessionId, async current => {
@@ -179,6 +186,21 @@ export function createSessionService(ports) {
     }, { kinds: ["session"] });
   }
 
+  /** The participant's most recent session, open or closed, or null. */
+  async function lastSessionOf({ participantId, workspaceId }) {
+    const resolved = workspaceId ?? store.workspaceId;
+    const snapshot = resolved === undefined ? null
+      : await store.snapshot(resolved, { kinds: ["workspace", "session"] });
+    const records = snapshot?.workspace === null
+      ? await store.ephemeral.list("session")
+      : snapshot?.sessions ?? await store.ephemeral.list("session");
+    const [last] = records.filter(session => session.participantId === participantId)
+      .sort((left, right) => Date.parse(right.heartbeatAt) - Date.parse(left.heartbeatAt)
+        || right.sessionId.localeCompare(left.sessionId));
+    return last === undefined ? null : { sessionId: last.sessionId, generation: last.generation,
+      state: last.state, endReason: last.extensions?.endReason ?? null };
+  }
+
   async function listLiveSessions({ participantId, workspaceId, now = clock.now() }) {
     const resolved = workspaceId ?? store.workspaceId;
     const snapshot = resolved === undefined ? null
@@ -198,6 +220,7 @@ export function createSessionService(ports) {
     resumeSession,
     heartbeatSession,
     closeSession,
+    lastSessionOf,
     listLiveSessions,
     locateSession: locate,
     ensureMaterialised: options => ensureMaterialised(ports, options),