agents-can-communicate 0.6.2 → 0.7.0

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

@@ -0,0 +1,241 @@
+import { AccError, EXIT } from "@agents-can-communicate/protocol";
+
+import { classifySessionPresence } from "./sessions.mjs";
+
+// What an operator can ask to reclaim. The workspace record is deliberately
+// absent: removing it would not clean a workspace, it would erase one.
+export const PRUNE_CLASSES = Object.freeze(["sessions", "intents", "claims", "participants"]);
+
+function assertClasses(classes) {
+  for (const name of classes) {
+    if (!PRUNE_CLASSES.includes(name)) {
+      throw new AccError(EXIT.USAGE,
+        `prune class is one of ${PRUNE_CLASSES.join(", ")}`, { class: name });
+    }
+  }
+}
+
+const of = (envelopes, kind) => envelopes.filter(envelope => envelope.kind === kind);
+
+const CURSOR = /^[0-9]{16}$/;
+const EVENT_PAGE = 500;
+
+function assertBefore(before) {
+  if (typeof before !== "string" || !CURSOR.test(before)) {
+    throw new AccError(EXIT.USAGE,
+      "before is the 16-digit cursor a previous sync returned", { before });
+  }
+  return before;
+}
+
+/**
+ * Read the log up to the boundary, counting it and naming what it recorded.
+ *
+ * The boundary is a cursor rather than a date on purpose: a cursor is what
+ * `sync` already returns and what a peer already holds, so an operator trimming
+ * to one names the same point its readers name. A duration would have to be
+ * resolved to a sequence anyway, and the resolution could move between the
+ * report and the apply.
+ */
+async function readBelow(store, workspaceId, before) {
+  const messageIds = new Set();
+  let events = 0;
+  let cursor = null;
+  for (;;) {
+    const page = await store.eventsSince(workspaceId, cursor, EVENT_PAGE);
+    if (page.events.length === 0) break;
+    let past = false;
+    for (const event of page.events) {
+      if (event.sequence > before) {
+        past = true;
+        break;
+      }
+      events += 1;
+      if (event.type === "message.recorded") messageIds.add(event.payload.messageId);
+    }
+    if (past) break;
+    cursor = page.cursor;
+  }
+  return { events, messageIds };
+}
+
+/**
+ * A message is resolved when nobody is still owed it.
+ *
+ * Offered is not read and retrieved is not model attention, so only an
+ * acknowledged receipt settles the obligation. A recipient that no longer
+ * exists cannot acknowledge anything, and holding the message for it would
+ * keep the whole thread forever.
+ */
+function resolvedMessages(envelopes, messageIds) {
+  const participants = new Set(of(envelopes, "participant").map(envelope => envelope.id));
+  const open = new Set(of(envelopes, "receipt").map(envelope => envelope.record)
+    .filter(receipt => receipt.state !== "acknowledged"
+      && participants.has(receipt.recipientParticipantId))
+    .map(receipt => receipt.messageId));
+  return of(envelopes, "message")
+    .filter(envelope => messageIds.has(envelope.id) && !open.has(envelope.id));
+}
+
+/**
+ * Which records describe work that has stopped for good.
+ *
+ * Only `offline` qualifies for a session, which is a confirmed dead pid or a
+ * full day without a heartbeat. `stale` is a session that has gone quiet, and a
+ * quiet session is still someone's.
+ */
+function eligibleSessions(envelopes, now, pidIsAlive) {
+  // A live claim names the session that holds it, and that name is how a peer
+  // blocked by the claim finds someone to ask. Removing the session leaves the
+  // claim reading as owned by nobody, so a session keeping a live lease stays
+  // however long it has been quiet. Its claim expiring makes both eligible.
+  const holding = new Set(of(envelopes, "claim")
+    .filter(envelope => Date.parse(envelope.record.expiresAt) > Date.parse(now))
+    .map(envelope => envelope.record.ownerSessionId));
+  return of(envelopes, "session")
+    .filter(envelope => !holding.has(envelope.id)
+      && classifySessionPresence(envelope.record, now, pidIsAlive) === "offline");
+}
+
+/**
+ * A participant is kept while anything still points at it.
+ *
+ * `removedSessions` is what this pass actually takes, not what it could take.
+ * The difference matters when an operator names classes: asked for participants
+ * alone, every session stays, so every participant is still pointed at and none
+ * is eligible. Judging by what is merely *eligible* would remove a participant
+ * and leave its sessions naming a roster entry that is gone.
+ *
+ * Messages are not pruned unless a boundary says so, and the roster is where
+ * "who sent this" is answered, so a name on a surviving message stays too.
+ */
+function eligibleParticipants(envelopes, removedSessions, messages) {
+  const surviving = new Set(of(envelopes, "session")
+    .filter(envelope => !removedSessions.has(envelope.id))
+    .map(envelope => envelope.record.participantId));
+  const named = new Set(messages.flatMap(message =>
+    [message.fromParticipantId, ...message.toParticipantIds]));
+  return of(envelopes, "participant")
+    .filter(envelope => !surviving.has(envelope.id) && !named.has(envelope.id));
+}
+
+export function createPruneService(ports) {
+  const { store, clock, pidIsAlive } = ports;
+
+  /**
+   * What `prune` would reclaim, as records rather than as counts.
+   *
+   * The plan is computed outside the writer mutex and applied inside it, so
+   * every entry carries the generation that proves it is still the record this
+   * judged. A claim renewed in between is skipped by the store rather than
+   * removed.
+   */
+  async function planPrune(input = {}) {
+    const classes = input.classes ?? PRUNE_CLASSES;
+    assertClasses(classes);
+    const workspaceId = input.workspaceId ?? store.workspaceId;
+    const now = clock.now();
+    const envelopes = await store.stateEnvelopes(workspaceId);
+    const wants = name => classes.includes(name);
+
+    const eligible = wants("sessions") || wants("intents") || wants("participants")
+      ? eligibleSessions(envelopes, now, pidIsAlive)
+      : [];
+    const sessions = wants("sessions") ? eligible : [];
+    const removedSessions = new Set(sessions.map(envelope => envelope.id));
+    const eligibleSessionIds = new Set(eligible.map(envelope => envelope.id));
+
+    // An intent belongs to one session and outlives nothing, so a session
+    // leaving takes its intent with it whether or not the operator named the
+    // class. Asking for intents alone reaches further: every intent whose
+    // session has stopped, including sessions this pass is keeping. Nothing
+    // points at an intent, so removing one leaves nothing dangling - but
+    // leaving one behind when its session goes would.
+    const owning = wants("intents") ? eligibleSessionIds : removedSessions;
+    const intents = of(envelopes, "intent")
+      .filter(envelope => owning.has(envelope.record.sessionId));
+    const claims = wants("claims")
+      ? of(envelopes, "claim")
+        .filter(envelope => Date.parse(envelope.record.expiresAt) <= Date.parse(now))
+      : [];
+
+    // History is named by a boundary rather than by a class, because there is
+    // no such thing as an event that has stopped being true - only one the
+    // operator has decided nobody will read again.
+    const before = input.before === undefined ? null : assertBefore(input.before);
+    const below = before === null ? { events: 0, messageIds: new Set() }
+      : await readBelow(store, workspaceId, before);
+    const messages = before === null ? [] : resolvedMessages(envelopes, below.messageIds);
+    const doomedMessages = new Set(messages.map(envelope => envelope.id));
+    const receipts = of(envelopes, "receipt")
+      .filter(envelope => doomedMessages.has(envelope.record.messageId));
+
+    // Decided after the messages, and against the ones that will survive this
+    // pass. A participant named only by a message the same run removes is a
+    // participant nothing will point at once the run finishes; judging it
+    // against every message that exists now would keep it, report no work
+    // remaining, and need a second identical run to reclaim it.
+    const participants = wants("participants")
+      ? eligibleParticipants(envelopes, removedSessions, of(envelopes, "message")
+        .map(envelope => envelope.record).filter(record => !doomedMessages.has(record.messageId)))
+      : [];
+
+    const named = { sessions, intents, claims, participants, messages, receipts };
+    // Ordered so that anything holding a reference goes before what it refers
+    // to. A pass can stop at its budget or its deadline, and what it has done
+    // by then is a prefix of this list - so the prefix has to be a state the
+    // store can be left in. A receipt names a message, a message and an intent
+    // and a claim each name a session, and a session names a participant.
+    // Removing them in that order means an interrupted pass never leaves a
+    // record pointing at one that is already gone.
+    const order = ["receipts", "messages", "intents", "claims", "sessions", "participants"];
+    const entries = order.flatMap(name => named[name])
+      .map(({ kind, id, generation }) => ({ kind, id, generation }));
+    return { workspaceId,
+      before,
+      counts: { ...Object.fromEntries(Object.entries(named)
+        .map(([name, list]) => [name, list.length])), events: below.events },
+      entries };
+  }
+
+  /**
+   * Reclaim what the plan named, or report it and change nothing.
+   *
+   * The dry run is the default because this is the one command that takes
+   * records out of the store. A caller that means it says so.
+   */
+  async function prune(input = {}) {
+    let plan = await planPrune(input);
+    if (input.apply !== true) {
+      return { ...plan, applied: false, reclaimed: 0, skipped: 0, remaining: false,
+        trimmedThrough: null };
+    }
+    // Decided again inside the writer mutex, and that second reading is the one
+    // acted on. Eligibility here is relational - a participant is eligible
+    // because no session of theirs survives - and a generation proves only that
+    // one record did not change. A session opening between the report and the
+    // apply changes the answer without changing any record this had named.
+    let decided = plan;
+    const result = await store.reclaimRecords(async () => {
+      decided = await planPrune(input);
+      return decided.entries;
+    }, { limit: input.limit, deadlineAt: input.deadlineAt });
+    if (decided.before === null) {
+      return { ...decided, applied: true, ...result, trimmedThrough: null };
+    }
+    plan = decided;
+    // Records first, then the log. A message removed while its recording event
+    // survives reads as history describing a record that is gone, which is
+    // ordinary. The reverse - an event log that starts after a message it never
+    // mentions - is the gap the floor is there to report.
+    const trimmed = await store.trimHistory(plan.before,
+      { limit: input.limit, deadlineAt: input.deadlineAt });
+    return { ...plan, applied: true,
+      reclaimed: result.reclaimed + trimmed.reclaimed,
+      skipped: result.skipped,
+      trimmedThrough: trimmed.trimmedThrough,
+      remaining: result.remaining || trimmed.remaining };
+  }
+
+  return { planPrune, prune };
+}

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

@@ -5,6 +5,7 @@ import { createIntentService } from "./intents.mjs";
 import { createInboxService } from "./inbox.mjs";
 import { defaultPidIsAlive } from "./pid.mjs";
 import { assertPorts } from "./ports.mjs";
+import { createPruneService } from "./prune.mjs";
 import { createReceiptService } from "./receipts.mjs";
 import { createSessionService } from "./sessions.mjs";
 import { createGuardStateService, createStatusService } from "./status.mjs";
@@ -37,6 +38,7 @@ export function createCoordinationService({ store, clock, ids,
   const sync = createSyncService(ports, sessions);
   const status = createStatusService(ports, sessions, deliveryBindings);
   const guardState = createGuardStateService(ports);
+  const prune = createPruneService(ports);
   return Object.freeze({
     store,
     clock,
@@ -62,6 +64,7 @@ export function createCoordinationService({ store, clock, ids,
     ...receipts,
     ...sync,
     ...status,
+    ...prune,
     guardState,
   });
 }

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

@@ -1,5 +1,6 @@
 import { classifySessionPresence } from "./sessions.mjs";
 import { computeAttention } from "./attention.mjs";
+import { isCurrentIntent } from "./intents.mjs";
 
 /**
  * Protection level, reported from what is actually enforceable.
@@ -108,7 +109,11 @@ export function createStatusService(ports, sessions, deliveryBindings) {
         enforcement: session.enforcement ?? "advisory",
         lifecycle: session.lifecycle ?? "manual",
         presence,
-        intent: intents.find(intent => intent.sessionId === session.sessionId)?.summary ?? null,
+        // A finished intent reads as no intent at all. `--clear` exists so a
+        // peer stops seeing work that has stopped, and reporting the summary of
+        // a done record made the command and this line contradict each other.
+        intent: intents.find(intent => intent.sessionId === session.sessionId
+          && isCurrentIntent(intent))?.summary ?? null,
       })),
       // 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

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

@@ -86,6 +86,10 @@ export function createSyncService(ports, sessions) {
       && snapshot.claims.length === 0;
     return {
       cursor: page.cursor,
+      // Where the log starts, when it no longer starts at the beginning. A
+      // caller whose cursor precedes this was served a short page, and saying
+      // so is the difference between a trim and a silent gap.
+      trimmedThrough: page.trimmedThrough ?? null,
       scope: input.scope === "full" ? "full" : "delta",
       solo,
       attention,

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/delivery-router",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "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.6.2",
+  "version": "0.7.0",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -3,10 +3,20 @@ import { readInstalledLivePolicyState } from "@agents-can-communicate/installer"
 
 import { establishNativeBinding, LIVE_POLICIES, livePolicyFrom } from "./native-binding.mjs";
 
-// Reserve time for turn projection, status and output before optional disk I/O.
+// A cold worker plus the write has to finish inside this window. 250 ms was
+// not enough on a busy CI runner, so the attempt file never appeared and
+// doctor reported no attempt. 1.5 s still abandons a stuck disk, and the
+// extra 500 ms stays available for turn projection, status and output.
+const DIAGNOSTIC_BUDGET_MS = 1_500;
+const DIAGNOSTIC_FLOOR_MS = 250;
+const AFTER_DIAGNOSTIC_MS = 500;
+
 export function nativeDiagnosticDeadline(hookDeadline) {
   const now = Date.now();
-  return hookDeadline - now >= 750 ? now + 250 : null;
+  const remaining = hookDeadline - now;
+  // Below this, even the old quarter-second write would crowd out projection.
+  if (remaining < DIAGNOSTIC_FLOOR_MS + AFTER_DIAGNOSTIC_MS) return null;
+  return now + Math.min(DIAGNOSTIC_BUDGET_MS, remaining - AFTER_DIAGNOSTIC_MS);
 }
 
 // The diagnostic has its own bounded writer; it never rewrites hook ownership.
@@ -45,12 +55,44 @@ export async function bindNative({ adapter, event, hookBinding, clientVersion, p
 const HINT_MAX_BYTES = 512;
 const HINT_MAX_MS = 250;
 
+function asHint(value) {
+  if (typeof value === "string") return { line: value, release: async () => {} };
+  if (value !== null && typeof value === "object" && typeof value.line === "string") {
+    return { line: value.line,
+      release: typeof value.release === "function" ? value.release : async () => {} };
+  }
+  if (value !== null && typeof value === "object" && typeof value.release === "function") {
+    return { line: "", release: value.release };
+  }
+  return null;
+}
+
+function usableHint(line) {
+  return line !== "" && !/[\r\n]/.test(line) && Buffer.byteLength(line, "utf8") <= HINT_MAX_BYTES;
+}
+
+// An adapter may release with a synchronous function. Calling `.catch` on its
+// return value throws when that return value is undefined, and a throw from
+// the function itself must not become a failed hook.
+export function callRelease(release) {
+  if (typeof release !== "function") return Promise.resolve();
+  try {
+    return Promise.resolve(release()).catch(() => {});
+  } catch {
+    return Promise.resolve();
+  }
+}
+
 /**
  * One line an adapter asks the agent to act on, when the agent itself can fix
  * a degraded native binding - Antigravity's relay is started from the agent's
  * own shell, and nothing else can start it. Bounded and fail-open: a slow or
  * failing adapter costs the turn nothing, and anything but one short line is
  * dropped rather than trusted into model context.
+ *
+ * A string has nothing reserved. `{ line, release }` has reserved an ask; this
+ * function calls `release` when it drops the line, including when the adapter
+ * answers after the budget. The caller releases a line it does not deliver.
  */
 export async function nativeActivationHintFor({ adapter, event, nativeBinding, binding, context,
   paths, deadline }) {
@@ -58,17 +100,28 @@ export async function nativeActivationHintFor({ adapter, event, nativeBinding, b
   const budget = Math.min(HINT_MAX_MS, deadline - Date.now() - HINT_MAX_MS);
   if (budget <= 0) return null;
   let timer = null;
+  let keep = false;
+  // The call sits inside then so a synchronous throw becomes a rejection.
+  // Promise.resolve(adapter.nativeActivationHint()) evaluates the call first
+  // and lets that throw escape the hook.
+  const pending = Promise.resolve().then(() => adapter.nativeActivationHint({ event, nativeBinding,
+    runtimeDir: paths.root, clientPid: binding?.clientPid, env: context.env })).then(asHint, () => null);
   try {
-    const line = await Promise.race([
-      Promise.resolve(adapter.nativeActivationHint({ event, nativeBinding, runtimeDir: paths.root,
-        clientPid: binding?.clientPid, env: context.env })),
+    const taken = await Promise.race([
+      pending,
       new Promise(resolve => { timer = setTimeout(resolve, budget, null); }),
     ]);
-    return typeof line === "string" && line !== "" && !/[\r\n]/.test(line)
-      && Buffer.byteLength(line, "utf8") <= HINT_MAX_BYTES ? line : null;
+    if (taken !== null && usableHint(taken.line)) {
+      keep = true;
+      return taken;
+    }
+    return null;
   } catch {
     return null;
   } finally {
     if (timer !== null) clearTimeout(timer);
+    // A late or rejected answer still holds its reservation. Do not wait for
+    // it: an adapter that never settles must not hold the hook.
+    if (!keep) pending.then(taken => callRelease(taken?.release)).catch(() => {});
   }
 }

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

@@ -15,7 +15,8 @@ import { clearPin, createGitProbe, resolveHookWorkspace, platformDataHome, runti
 
 import { resolveClientPid } from "./client-pid.mjs";
 import { probeClientVersion as defaultProbeClientVersion } from "./client-version.mjs";
-import { bindNative, nativeActivationHintFor, nativeDiagnosticDeadline } from "./native-attempt.mjs";
+import { bindNative, callRelease, nativeActivationHintFor, nativeDiagnosticDeadline }
+  from "./native-attempt.mjs";
 import { readProcessTable as defaultReadProcessTable } from "./process-table.mjs";
 import { withSessionLifecycle } from "./session-lifecycle.mjs";
 import { appendStartOwner, appendToolOwner, ownerHeader, ownerOnlyOutcome } from "./owner-context.mjs";
@@ -264,14 +265,17 @@ async function projectTurn({ binding, context, adapter, adapterId,
   // turn carries - and only when both fit in half the budget, so peer bodies
   // always keep the rest.
   const header = ownerHeader(binding, context.workspaceCwd, context.workspaceRef);
-  const owner = activationHint === null
-    || byteLength(header) + 1 + byteLength(activationHint) > totalBudget / 2
-    ? header : `${header}\n${activationHint}`;
+  const hintFits = activationHint !== null
+    && byteLength(header) + 1 + byteLength(activationHint) <= totalBudget / 2;
+  const owner = hintFits ? `${header}\n${activationHint}` : header;
+  const withHint = (outcome, attached) => ({ ...outcome,
+    activationHintIncluded: attached === true && outcome.stdout !== "" });
   // A peer can join after this prompt has begun. The current turn must already
   // have its own arguments when it needs inbox/reply, without reattaching or
   // waiting for another user prompt. Solo emits identity, not a peer notice.
   if (sync.solo && messages.length === 0) {
-    return ownerOnlyOutcome(text => adapter.injectOutcome?.(text), owner, totalBudget);
+    return withHint(ownerOnlyOutcome(text => adapter.injectOutcome?.(text), owner, totalBudget),
+      hintFits);
   }
 
   // The ceiling a team agreed on in `acc.workspace.json`, or the default when
@@ -324,12 +328,13 @@ async function projectTurn({ binding, context, adapter, adapterId,
   // Own claims make sync non-solo but produce no peer context. They cannot
   // remove this turn's identity or consume a nonexistent body separator.
   if (body === "" && messages.length === 0) {
-    return ownerOnlyOutcome(text => adapter.injectOutcome?.(text), owner, totalBudget);
+    return withHint(ownerOnlyOutcome(text => adapter.injectOutcome?.(text), owner, totalBudget),
+      hintFits);
   }
   const projected = body === "" ? "" : ownerFits ? `${owner}\n${body}` : body;
   if (projected === "") {
-    return { stdout: "", stderr: messages.length === 0 ? ""
-      : [ownerWarning, degradation].filter(Boolean).join("\n") };
+    return withHint({ stdout: "", stderr: messages.length === 0 ? ""
+      : [ownerWarning, degradation].filter(Boolean).join("\n") }, false);
   }
 
   // The renderer returns ids as metadata, never as text to parse. A peer body
@@ -349,9 +354,30 @@ async function projectTurn({ binding, context, adapter, adapterId,
   // callback proves that the bytes crossed.
   const outcome = { stdout: "", ...render(projected) };
   const writableOffers = outcome.stdout === "" ? [] : offerInputs;
-  return { ...outcome,
+  return withHint({ ...outcome,
     stderr: [outcome.stderr, ownerWarning, degradation].filter(Boolean).join("\n"),
-    offerInputs: writableOffers };
+    offerInputs: writableOffers }, hintFits && ownerFits);
+}
+
+// The adapter may already have reserved an ask. That reservation is an ask
+// only when this turn's stdout carries the line. A throw discards the turn,
+// so the reservation goes with it.
+async function projectActivation(input, offered) {
+  try {
+    const turn = await projectTurn({ ...input, activationHint: offered?.line ?? null });
+    const included = turn.activationHintIncluded === true;
+    delete turn.activationHintIncluded;
+    if (!offered) return turn;
+    if (!included) await callRelease(offered.release);
+    else if (typeof offered.release === "function") {
+      const release = offered.release;
+      turn.releaseActivationAsk = () => callRelease(release);
+    }
+    return turn;
+  } catch (error) {
+    await callRelease(offered?.release);
+    throw error;
+  }
 }
 
 const HANDLERS = {
@@ -500,9 +526,9 @@ const HANDLERS = {
       const started = await HANDLERS.sessionStart(input);
       const fresh = await loadSessionBinding({ runtimeDir: paths.root,
         harnessSessionId: event.sessionId });
-      const activationHint = await nativeActivationHintFor({ adapter, event,
+      const offered = await nativeActivationHintFor({ adapter, event,
         nativeBinding: started.nativeBinding, binding: fresh, context, paths, deadline });
-      const turn = await projectTurn({ ...input, binding: fresh, activationHint });
+      const turn = await projectActivation({ ...input, binding: fresh }, offered);
       return { ...turn, nativeBinding: started.nativeBinding };
     }
     const current = await context.service.locateSession(binding.accSessionId);
@@ -516,9 +542,9 @@ const HANDLERS = {
       const started = await HANDLERS.sessionStart(input);
       const fresh = await loadSessionBinding({ runtimeDir: paths.root,
         harnessSessionId: event.sessionId });
-      const activationHint = await nativeActivationHintFor({ adapter, event,
+      const offered = await nativeActivationHintFor({ adapter, event,
         nativeBinding: started.nativeBinding, binding: fresh, context, paths, deadline });
-      const turn = await projectTurn({ ...input, binding: fresh, activationHint });
+      const turn = await projectActivation({ ...input, binding: fresh }, offered);
       return { ...turn, nativeBinding: started.nativeBinding };
     }
     // A turn is the clearest sign a session is alive. Never a reason to fail:
@@ -530,9 +556,9 @@ const HANDLERS = {
     const nativeBinding = await bindNative({ adapter, event, hookBinding: binding,
       clientVersion: binding.clientVersion, platform: binding.platform, context, paths,
       deadline });
-    const activationHint = await nativeActivationHintFor({ adapter, event, nativeBinding,
+    const offered = await nativeActivationHintFor({ adapter, event, nativeBinding,
       binding, context, paths, deadline });
-    const turn = await projectTurn({ ...input, activationHint });
+    const turn = await projectActivation(input, offered);
     return nativeBinding === undefined ? turn : { ...turn, nativeBinding };
   },
 

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/installer",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "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.6.2",
+  "version": "0.7.0",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/protocol",
-  "version": "0.6.2",
+  "version": "0.7.0",
   "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.6.2",
+  "version": "0.7.0",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -34,11 +34,11 @@ async function bytesIfPresent(filePath, root, openFile) {
   }
 }
 
-function retainedStage(destination, root, tmpDir) {
+function retainedStage(destination, root, stageDir) {
   const identity = createHash("sha256")
     .update(path.relative(root, destination))
     .digest("hex");
-  return path.join(tmpDir, `${identity}.published`);
+  return path.join(stageDir, `${identity}.published`);
 }
 
 async function replaceHandleBytes(handle, bytes) {
@@ -63,11 +63,18 @@ async function replaceHandleBytes(handle, bytes) {
  *
  * @returns {Promise<"published" | "already_published">}
  */
-export async function publishAtomic(destination, bytes, { root, tmpDir, replace = false, deadlineAt }) {
+export async function publishAtomic(destination, bytes,
+  { root, tmpDir, stageDir, replace = false, deadlineAt, afterAccepted }) {
   assertPublicationDeadline(deadlineAt);
+  // The accepted stage lives apart from the partial a failed publication
+  // leaves, so what a file is follows from the directory it was created in
+  // rather than from how its name ends. Defaulted from the root the way
+  // active-journal.mjs defaults tmpDir, so every caller keeps working.
+  stageDir = stageDir ?? path.join(root, "stage");
   const destinationDir = path.dirname(destination);
   await Promise.all([
     ensureManagedDirectory(root, tmpDir),
+    ensureManagedDirectory(root, stageDir),
     ensureManagedDirectory(root, destinationDir),
   ]);
   if (!replace) {
@@ -79,8 +86,11 @@ export async function publishAtomic(destination, bytes, { root, tmpDir, replace
     }
   }
 
-  const stage = retainedStage(destination, root, tmpDir);
-  const temporary = `${stage}.${process.pid}.${randomUUID()}.tmp`;
+  const stage = retainedStage(destination, root, stageDir);
+  // The temporary stays in tmpDir: until the bytes are accepted it is a
+  // partial, and a partial is exactly what tmp holds.
+  const temporary = path.join(tmpDir,
+    `${path.basename(stage)}.${process.pid}.${randomUUID()}.tmp`);
   let handle = await open(temporary, "wx");
   let stageAcceptedBytes = false;
   try {
@@ -121,9 +131,18 @@ export async function publishAtomic(destination, bytes, { root, tmpDir, replace
   } finally {
     await handle?.close();
     if (stageAcceptedBytes) {
-      await assertManagedDirectory(root, tmpDir);
+      // `ensure`, not `assert`: the sweep empties this directory by renaming it
+      // aside and recreating it, and a publication that began before that swap
+      // arrives here to find the name gone. Both apply the same managed-root
+      // checks - the only difference is that this one recreates what the sweep
+      // has already taken away, instead of failing a write whose bytes are
+      // already published.
+      // The seam the race test uses, in the manner retainFile already
+      // establishes: the window this closes is invisible without one.
+      await afterAccepted?.();
+      await ensureManagedDirectory(root, stageDir);
       await rename(temporary, stage);
-      await syncDirectory(tmpDir);
+      await syncDirectory(stageDir);
     } else {
       // A crash/error before immutable acceptance keeps its unique partial.
       // Retention avoids the unsafe parent-check/unlink pathname window, while