agents-can-communicate 0.10.4 → 0.11.1

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

@@ -1,6 +1,7 @@
-import { AccError, EXIT, SCHEMA_VERSION, assertMatchableResource, createId,
-  normaliseResource, validateRecord } from "@agents-can-communicate/protocol";
+import { AccError, EXIT, SCHEMA_VERSION, createId, validateRecord }
+  from "@agents-can-communicate/protocol";
 
+import { claimResources, releaseSelectors, selectReleaseClaims } from "./claim-selectors.mjs";
 import { ensureMaterialised } from "./materialisation.mjs";
 import { classifySessionPresence } from "./sessions.mjs";
 
@@ -33,10 +34,11 @@ const isLive = (claim, now) => Date.parse(claim.expiresAt) > Date.parse(now);
 export function createClaimService(ports, sessions) {
   const { store, clock, ids, pidIsAlive } = ports;
 
-  async function requireOwner(input, action, tx) {
+  async function requireOwner(input, action, tx, allowEphemeral = false) {
     const current = tx === undefined
       ? (await sessions.locateSession(input.sessionId, input.workspaceId))?.record
-      : tx.get("session", input.sessionId);
+      : tx.get("session", input.sessionId)
+        ?? (allowEphemeral ? await store.ephemeral.get("session", input.sessionId) : null);
     if (current == null || current.state !== "open") {
       throw new AccError(EXIT.CONFLICT, `cannot ${action} from a session that is not open`,
         { sessionId: input.sessionId });
@@ -65,63 +67,66 @@ export function createClaimService(ports, sessions) {
     });
   }
 
-  async function acquireClaim(input) {
+  async function acquire(input, resources, batch) {
     const session = await requireOwner(input, "claim");
-    // One name for one file, decided here rather than at each surface, so a
-    // claim taken over MCP and one taken from the CLI mean the same thing - and
-    // a shape that could never match is refused rather than stored.
-    assertMatchableResource(input.resource, message => {
-      throw new AccError(EXIT.USAGE, message, { resource: input.resource });
-    });
-    const resource = normaliseResource(input.resource);
+    resources = claimResources(resources);
     const workspaceId = session.workspaceId;
     await ensureMaterialised(ports, { workspaceId, descriptor: input.descriptor,
       reason: "durable_object" });
-    const now = clock.now();
-    const expiresAt = new Date(Date.parse(now) + (input.leaseSeconds ?? 1800) * 1000)
-      .toISOString();
-    // Only to name the owner of a conflicting claim in the error.
-    const snapshot = await store.snapshot(workspaceId, { kinds: ["session"] });
-
-    let record = null;
-    await store.transaction(async tx => {
+    return store.transaction(async tx => {
       await requireOwner(input, "claim", tx);
-      const live = tx.list("claim", claim => isLive(claim, now));
-      // This session's own claim on this resource, live or lapsed. Looking only
-      // among the live ones left the expired record behind and made a fresh one
-      // beside it, so taking a resource back after a lease ran out reported
-      // success while the workspace still held a dead claim saying otherwise -
-      // and the owner went on being told its claim had run out.
-      const mine = tx.list("claim", claim => claim.ownerSessionId === session.sessionId
-        && claim.resource === resource).at(0);
-      const blocking = live.find(claim => overlaps(claim.resource, resource)
-        && claim.ownerSessionId !== session.sessionId
-        && (claim.mode === "exclusive" || input.mode === "exclusive"));
-      if (blocking !== undefined) throw conflictWith(blocking, session, now, snapshot.sessions);
-
-      const claimId = mine?.claimId ?? createId("claim");
-      record = validateRecord("claim", {
-        schemaVersion: SCHEMA_VERSION,
-        claimId,
-        workspaceId,
-        ownerSessionId: session.sessionId,
-        resource,
-        mode: input.mode ?? "exclusive",
-        enforcement: input.enforcement ?? "advisory",
-        reason: input.reason,
-        // A lapsed claim taken again is a new period of holding it, not a
-        // continuation of one that ended.
-        acquiredAt: mine !== undefined && isLive(mine, now) ? mine.acquiredAt : now,
-        expiresAt,
-        generation: ids.next("generation"),
+      const now = clock.now();
+      const expiresAt = new Date(Date.parse(now) + (input.leaseSeconds ?? 1800) * 1000)
+        .toISOString();
+      const existing = tx.list("claim");
+      const live = existing.filter(claim => isLive(claim, now));
+      const mode = input.mode ?? "exclusive";
+      const conflicts = resources.flatMap(resource => live
+        .filter(claim => overlaps(claim.resource, resource)
+          && claim.ownerSessionId !== session.sessionId
+          && (claim.mode === "exclusive" || mode === "exclusive"))
+        .map(claim => ({ requestedResource: resource,
+          ...conflictWith(claim, session, now, tx.list("session")).details })));
+      if (conflicts.length > 0) {
+        if (!batch) {
+          const { requestedResource, ...details } = conflicts[0];
+          throw new AccError(EXIT.CONFLICT, "the resource is already claimed", details);
+        }
+        const message = "batch claim conflicts:\n" + conflicts.map(conflict =>
+          `${conflict.requestedResource} overlaps ${conflict.resource}, held by ${conflict.ownerSessionId}`)
+          .join("\n");
+        throw new AccError(EXIT.CONFLICT, message, { conflicts });
+      }
+      // Validate every record before staging a write, including renewals.
+      const records = resources.map(resource => {
+        const mine = existing.find(claim => claim.ownerSessionId === session.sessionId
+          && claim.resource === resource);
+        const claimId = mine?.claimId ?? createId("claim");
+        return { mine, record: validateRecord("claim", {
+          schemaVersion: SCHEMA_VERSION,
+          claimId,
+          workspaceId,
+          ownerSessionId: session.sessionId,
+          resource,
+          mode,
+          enforcement: input.enforcement ?? "advisory",
+          reason: input.reason,
+          // Reuse a lapsed record, but start a new period of holding it.
+          acquiredAt: mine !== undefined && isLive(mine, now) ? mine.acquiredAt : now,
+          expiresAt,
+          generation: ids.next("generation"),
+        }) };
       });
-      tx.put("claim", claimId, record, tx.generationOf("claim", claimId));
-      tx.append({ schemaVersion: SCHEMA_VERSION, eventId: ids.next("event"), workspaceId,
-        actorSessionId: session.sessionId, type: mine === undefined ? "claim.acquired"
-          : "claim.renewed", occurredAt: now,
-        payload: { claimId, resource, mode: record.mode } });
+      for (const { mine, record } of records) {
+        const { claimId, resource } = record;
+        tx.put("claim", claimId, record, tx.generationOf("claim", claimId));
+        tx.append({ schemaVersion: SCHEMA_VERSION, eventId: ids.next("event"), workspaceId,
+          actorSessionId: session.sessionId, type: mine === undefined ? "claim.acquired"
+            : "claim.renewed", occurredAt: now,
+          payload: { claimId, resource, mode: record.mode } });
+      }
+      return records.map(item => item.record);
     }, { kinds: ["session", "claim"] });
-    return record;
   }
 
   async function renewClaim(input) {
@@ -146,40 +151,42 @@ export function createClaimService(ports, sessions) {
     return record;
   }
 
-  async function removeClaim(input, { authority, reason }) {
+  async function removeClaims(input, selectors, { authority = null, reason = null } = {}) {
     const session = await requireOwner(input, "release");
-    const now = clock.now();
-    await store.transaction(async tx => {
-      await requireOwner(input, "release", tx);
-      const existing = tx.get("claim", input.claimId);
-      if (existing === null) {
-        throw new AccError(EXIT.CONFLICT, "the claim does not exist", { claimId: input.claimId });
+    return store.transaction(async tx => {
+      await requireOwner(input, "release", tx, true);
+      const now = clock.now();
+      const selected = selectReleaseClaims(tx, selectors, session.sessionId);
+      for (const existing of selected) {
+        const owned = existing.ownerSessionId === session.sessionId;
+        if (!owned && authority !== "human" && authority !== "policy") {
+          throw new AccError(EXIT.CONFLICT,
+            "force release requires human or policy authority",
+            { claimId: existing.claimId, authority });
+        }
       }
-      const owned = existing.ownerSessionId === session.sessionId;
-      // Force release is an authority decision, not a peer decision. A
-      // coordinator lease does not extend outside its own workstream.
-      if (!owned && authority !== "human" && authority !== "policy") {
-        throw new AccError(EXIT.CONFLICT,
-          "force release requires human or policy authority",
-          { claimId: input.claimId, authority: authority ?? null });
+      for (const existing of selected) {
+        const owned = existing.ownerSessionId === session.sessionId;
+        // Remove the live record; per-resource events retain its history.
+        tx.remove("claim", existing.claimId, tx.generationOf("claim", existing.claimId));
+        tx.append({ schemaVersion: SCHEMA_VERSION, eventId: ids.next("event"),
+          workspaceId: existing.workspaceId, actorSessionId: session.sessionId,
+          type: owned ? "claim.released" : "claim.force_released", occurredAt: now,
+          payload: { claimId: existing.claimId, authority,
+            reason, replacedGeneration: existing.generation } });
       }
-      // The claim record is removed rather than tombstoned: a released claim is
-      // not a claim, and every consumer of a snapshot would otherwise have to
-      // re-derive liveness. The event log keeps the history.
-      tx.remove("claim", input.claimId, tx.generationOf("claim", input.claimId));
-      tx.append({ schemaVersion: SCHEMA_VERSION, eventId: ids.next("event"),
-        workspaceId: existing.workspaceId, actorSessionId: session.sessionId,
-        type: owned ? "claim.released" : "claim.force_released", occurredAt: now,
-        payload: { claimId: input.claimId, authority: authority ?? null,
-          reason: reason ?? null, replacedGeneration: existing.generation } });
+      return selected;
     }, { kinds: ["session", "claim"] });
   }
 
   return {
-    acquireClaim,
+    acquireClaim: async input => (await acquire(input, [input.resource], false))[0],
+    acquireClaims: input => acquire(input, input.resources, true),
     renewClaim,
-    releaseClaim: input => removeClaim(input, { authority: null, reason: null }),
-    forceReleaseClaim: input => removeClaim(input,
-      { authority: input.authority, reason: input.reason }),
+    releaseClaims: async input => removeClaims(input, releaseSelectors(input)),
+    releaseClaim: async input => { await removeClaims(input, { claimIds: [input.claimId] }); },
+    forceReleaseClaim: async input => { await removeClaims(input, { claimIds: [input.claimId] },
+      { authority: input.authority, reason: input.reason });
+    },
   };
 }

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

@@ -6,7 +6,8 @@ export async function nextTurnDelivery(store, input = {}) {
     return { queuedMessages: [], liveOfferedMessageIds: [], reminderMessageIds: [],
       roomMessageIds: [], repeatMessages: [], repeatOffers: [] };
   }
-  const snapshot = await store.snapshot(input.workspaceId ?? store.workspaceId,
+  // A caller that has just read the store hands that read over (#298).
+  const snapshot = input.snapshot ?? await store.snapshot(input.workspaceId ?? store.workspaceId,
     { kinds: ["message", "receipt"] });
   const receiptByMessage = new Map(snapshot.receipts
     .filter(item => item.recipientParticipantId === input.participantId)

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

@@ -101,12 +101,15 @@ export function createSessionService(ports) {
       : await store.ephemeral.update("session", sessionId, async current =>
         current !== null && !await isMaterialised(store, current.workspaceId) ? beat(current) : null);
     if (ephemeral !== null) return ephemeral;
-    return store.transaction(tx => {
+    // One session is read, not every session the workspace ever had: a turn's
+    // heartbeat took about a second in a workspace with 2,234 of them.
+    return store.transaction(async tx => {
+      await tx.load("session", sessionId);
       const beaten = beat(tx.get("session", sessionId));
       if (beaten === null) throw new AccError(EXIT.CONFLICT, "session is not open", { sessionId });
       tx.put("session", sessionId, beaten, tx.generationOf("session", sessionId));
       return beaten;
-    }, { kinds: ["session"] });
+    }, { kinds: ["session"], exactKinds: ["session"] });
   }
 
   /**

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

@@ -71,7 +71,8 @@ export function createSyncService(ports, sessions) {
     const located = input.sessionId === undefined
       ? null : await sessions.locateSession(input.sessionId, workspaceId);
     const session = located?.record ?? null;
-    const durable = await store.snapshot(workspaceId);
+    // A caller that reads the store once for a whole turn hands that read over (#298).
+    const durable = input.snapshot ?? await store.snapshot(workspaceId);
     const snapshot = durable.workspace !== null
       ? durable
       : { ...durable,

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

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

package/node_modules/@agents-can-communicate/delivery-router/src/router.mjs

@@ -1,12 +1,10 @@
-import { NATIVE_REASON_CODES, evaluateVersionContract, isLaunchOption }
+import { NATIVE_REASON_CODES, evaluateVersionContract, isLaunchOption, OFFER_ERRORS, storeOfferObservation }
   from "@agents-can-communicate/adapter-sdk";
 
 import { lastNativeReason } from "./native-reason.mjs";
 import { refreshExpiredBinding } from "./refresh-binding.mjs";
 
-const SAFE_ERRORS = new Set(["ambiguous_recipient_sessions", "delivery_disabled",
-  "recipient_busy", "recipient_unavailable", "transport_error", "transport_rejected", "transport_permission_denied",
-  "unsupported_client_version"]);
+const SAFE_ERRORS = new Set(OFFER_ERRORS);
 const NAMED_LIVE_TRANSPORTS = new Set(["claude-inbox", "codex-app-server"]);
 
 const adaptersById = adapters => adapters instanceof Map
@@ -47,9 +45,20 @@ function safeTransport(value, opaqueEndpointRef) {
   return opaqueEndpointRef === "live-adapter" ? "native-live" : "live-adapter";
 }
 
-export function createDeliveryRouter({ service, adapters, clock, readLivePolicy,
+export function createDeliveryRouter({ service, adapters, loadAdapter, clock, readLivePolicy,
   readNativeReason = input => lastNativeReason({ runtimeDir: service.store?.root, ...input }) }) {
   const registry = adaptersById(adapters);
+  // A command that routes one message loads only its recipients' adapters (#270).
+  const adapterFor = typeof loadAdapter === "function" ? loadAdapter
+    : async adapterId => registry.get(adapterId);
+  const observeOffer = (binding, reasonCode = null) => {
+    // Capture time and order now, but never await optional diagnostic I/O on
+    // the delivery path. The SDK bounds its own lifetime for short-lived CLIs.
+    void storeOfferObservation({
+      runtimeDir: service.store?.root, workspaceId: service.store?.workspaceId,
+      sessionId: binding.sessionId, generation: binding.generation, at: clock.now(),
+      state: reasonCode === null ? "active" : "degraded", reasonCode }).catch(() => {});
+  };
 
   // A session that bound no live transport may have said why: the reason its
   // own last native attempt recorded, from the closed vocabulary only, and the
@@ -82,6 +91,7 @@ export function createDeliveryRouter({ service, adapters, clock, readLivePolicy,
       targetGeneration: binding.generation,
       transport: safeTransport(transport, binding.opaqueEndpointRef), adapterId: binding.adapterId,
       clientVersion: binding.clientVersion, safeErrorCode }).catch(() => null);
+    observeOffer(binding, safeErrorCode);
   }
 
   async function offerTo(message, participantId, now) {
@@ -112,7 +122,7 @@ export function createDeliveryRouter({ service, adapters, clock, readLivePolicy,
     // that bound no live transport. It reads its inbox, so it is not gone.
     if (bindings.length === 0) return withoutLiveTransport(participantId, target);
     const evaluated = await Promise.all(bindings.map(async binding => {
-      const adapter = registry.get(binding.adapterId);
+      const adapter = await adapterFor(binding.adapterId);
       return { binding, adapter, policy: await policyFor(adapter, binding) };
     }));
     const permitted = evaluated.filter(({ policy }) => permits(policy, message.kind));
@@ -135,7 +145,7 @@ export function createDeliveryRouter({ service, adapters, clock, readLivePolicy,
       if (!refreshed.refreshed) {
         if (refreshed.errorCode === "transport_permission_denied") {
           await recordFailure(binding, message, participantId, "live-adapter", refreshed.errorCode);
-        }
+        } else observeOffer(binding, refreshed.errorCode);
         return durable(participantId, refreshed.errorCode);
       }
       const current = (await service.listDeliveryBindings({
@@ -216,6 +226,7 @@ export function createDeliveryRouter({ service, adapters, clock, readLivePolicy,
     // shown and leave it out of the very turn the wake started. The receipt
     // stays queued; the hook records the offer once its stdout carried the body.
     if (adapter.nativeDelivery?.offerKind === "wake") {
+      observeOffer(binding, response.pendingApproval === true ? "inbound_approval_required" : null);
       // The client took the wake but holds it for its user's approval.
       return { recipientParticipantId: participantId, outcome: "woken", transport,
         ...(response.pendingApproval === true ? { pendingApproval: true } : {}) };
@@ -229,6 +240,7 @@ export function createDeliveryRouter({ service, adapters, clock, readLivePolicy,
       await recordFailure(binding, message, participantId, transport, "transport_error");
       return durable(participantId, "transport_error");
     }
+    observeOffer(binding);
     return { recipientParticipantId: participantId, outcome: "offered", transport };
   }
 

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

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

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

@@ -102,19 +102,31 @@ export function resolveClient({ table, from, command, clientPackage, identify,
     const entry = table.get(current);
     if (entry === undefined || seen.has(current)) return null;
     seen.add(current);
-    const product = recognised(identify, entry);
-    if (product !== null) {
-      return { pid: current, entry, certificationName: product.certificationName,
-        version: product.version };
-    }
-    // `ps` reports some entries bare (`claude`) and some with a path
-    // (`/bin/zsh`), so the comparison has to be on the basename.
-    if (imageName(entry.comm) === command
-      || scriptsOf(entry, clientPackage).some(name => name === command || name === CLIENT_PACKAGE)) {
-      return { pid: current, entry, certificationName: undefined, version: undefined };
-    }
+    const match = clientMatch(entry, { command, clientPackage, identify });
+    if (match !== null) return { pid: current, entry, ...match };
     if (entry.ppid === current || entry.ppid <= 1) return null;
     current = entry.ppid;
   }
   return null;
 }
+
+/** What one process-table entry is as the declared client, or null. */
+function clientMatch(entry, { command, clientPackage, identify }) {
+  const product = recognised(identify, entry);
+  if (product !== null) {
+    return { certificationName: product.certificationName, version: product.version };
+  }
+  // `ps` reports some entries bare (`claude`) and some with a path
+  // (`/bin/zsh`), so the comparison has to be on the basename.
+  if (imageName(entry.comm) === command
+    || scriptsOf(entry, clientPackage).some(name => name === command || name === CLIENT_PACKAGE)) {
+    return { certificationName: undefined, version: undefined };
+  }
+  return null;
+}
+
+/** Whether one entry is the client, as `resolveClient` would decide: a table
+ * read can stop there instead of reading the client's own parents. */
+export function isClientProcess(entry, { command, clientPackage, identify }) {
+  return clientMatch(entry, { command, clientPackage, identify }) !== null;
+}

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

@@ -15,7 +15,7 @@ import { clearPin, createGitProbe, resolveHookWorkspace, platformDataHome, runti
   writePin as writeRuntimePin }
   from "@agents-can-communicate/cli/hook-support";
 
-import { resolveClient } from "./client-pid.mjs";
+import { isClientProcess, resolveClient } from "./client-pid.mjs";
 import { ownExecutable, probeClientVersion as defaultProbeClientVersion, probeExecutableVersion }
   from "./client-version.mjs";
 import { bindNative, callRelease, nativeActivationHintFor, nativeDiagnosticDeadline }
@@ -44,6 +44,17 @@ const WINDOWS = process.platform === "win32";
 const PROCESS_TABLE_MS = WINDOWS ? 3_000 : 1_000;
 const TABLE_RESERVE_MS = WINDOWS ? 500 : 0;
 
+// How this adapter's client is recognised in a process table.
+const clientOf = adapter => ({ command: adapter.client?.command ?? null,
+  clientPackage: adapter.client?.package, identify: adapter.identifyClientProcess });
+
+// One bounded table read for a hook, which ends at the client it is looking for.
+function readClientTable(readProcessTable, adapter, deadline) {
+  return Promise.resolve(readProcessTable({
+    timeoutMs: Math.max(1, Math.min(PROCESS_TABLE_MS, deadline - Date.now() - TABLE_RESERVE_MS)),
+    until: entry => isClientProcess(entry, clientOf(adapter)) }));
+}
+
 function assertHookBudget(deadline, message = "hook deadline expired") {
   if (Date.now() >= deadline) throw new Error(message);
 }
@@ -252,8 +263,12 @@ async function openContext({ event, adapterId, dataHome, runtime, env, deadline
 // the adapter's context envelope, at the end of one it is a continuation.
 async function projectTurn({ binding, context, adapter, adapterId, render = null,
   activationHint = null, activationNotice = null, repeats = true }) {
+  // One read of the store serves the whole projection. Sync and next-turn
+  // delivery each read every message and receipt the workspace held, twice a
+  // prompt, and nothing is written between the two (#298).
+  const snapshot = await context.service.store.snapshot(context.descriptor.id);
   const sync = await context.service.sync({ sessionId: binding.accSessionId,
-    cursor: null, scope: "delta" });
+    cursor: null, scope: "delta", snapshot });
 
   // Sync already carries the roster. Calling collectStatus here used to read
   // the entire materialised store a second time on every prompt merely to
@@ -277,7 +292,7 @@ async function projectTurn({ binding, context, adapter, adapterId, render = null
     workspaceId: context.descriptor.id,
     participantId: mine?.participantId,
     exceptSessionId: binding.accSessionId,
-    repeats: repeats && canOfferNextTurn });
+    repeats: repeats && canOfferNextTurn, snapshot });
   // New bodies first, so a repeat is what the byte budget drops.
   const messages = [...delivery.queuedMessages, ...delivery.repeatMessages];
   const repeating = new Set(delivery.repeatMessages.map(message => message.messageId));
@@ -498,8 +513,8 @@ const HANDLERS = {
     // each can start a program. A session start began the read already, when
     // its event was known. Handled here so a probe that fails first leaves no
     // rejection unobserved.
-    const tableRead = known || command === null ? null : started ?? Promise.resolve(readProcessTable({
-      timeoutMs: Math.max(1, Math.min(PROCESS_TABLE_MS, deadline - Date.now() - TABLE_RESERVE_MS)) }));
+    const tableRead = known || command === null ? null
+      : started ?? readClientTable(readProcessTable, adapter, deadline);
     tableRead?.catch(() => {});
     // The binary on PATH answers in parallel, as the fallback: the version the
     // running client names for itself, when it names one, wins below.
@@ -507,8 +522,7 @@ const HANDLERS = {
       { timeoutMs: Math.max(1, Math.min(1_000, deadline - Date.now())) });
     mark("reading the process table");
     const client = known ? { pid: knownClientPid } : command === null ? null
-      : resolveClient({ table: await tableRead, from: process.pid, command,
-        clientPackage: adapter.client?.package, identify: adapter.identifyClientProcess });
+      : resolveClient({ table: await tableRead, from: process.pid, ...clientOf(adapter) });
     assertHookBudget(deadline);
     mark("probing the client version");
     const product = declaredProduct(adapter, client);
@@ -535,9 +549,9 @@ const HANDLERS = {
     };
     if (event.kind === "beforeTurn" && binding !== null) {
       // A genuine prompt can resume after an ephemeral removal or a durable
-      // close, or carry on a session whose client restarted. Recheck after
-      // probes: a CLI replacement can run outside the native lifecycle lock.
-      // Never adopt that replacement's identity.
+      // close, or carry on a session whose client restarted or was found only
+      // now. Recheck after probes: a CLI replacement can run outside the
+      // native lifecycle lock. Never adopt that replacement's identity.
       // A session can also close between the turn's check and this one while
       // its client was down; that is the closed-session resumption below,
       // not a replacement.
@@ -665,14 +679,28 @@ const HANDLERS = {
       const turn = await projectActivation({ ...input, binding: fresh }, offered);
       return { ...turn, nativeBinding: started.nativeBinding };
     }
-    if (clientGone(binding)) {
+    // A start that could not find its client opened the session without it:
+    // on 2026-10-12, at load average 56-84, the table read outlasted its limit.
+    // Every turn looks again until the client is found; nothing else would,
+    // and the session would stay without live delivery for its whole life.
+    // Only the open generation this binding names is rebound; a stale binding
+    // never reaches the start path, whatever the table says.
+    const known = Number.isInteger(binding.clientPid) && binding.clientPid > 0;
+    const bindable = current.record.state === "open" && current.record.generation === binding.generation;
+    const found = known || !bindable || clientOf(adapter).command === null ? null
+      : await readClientTable(input.readProcessTable, adapter, deadline);
+    const lateClient = found !== null
+      && resolveClient({ table: found, from: process.pid, ...clientOf(adapter) }) !== null;
+    if (lateClient || clientGone(binding)) {
       // The client this session was bound to has exited, and a turn arrived
       // anyway: the client restarted under the same conversation. Antigravity
       // 2.0 reopens a conversation without a second SessionStart, so without
       // this the session stayed bound to a dead process and lost live delivery
       // for good. The start path finds the client running now, keeps this ACC
-      // session and generation, and binds again.
-      const started = await HANDLERS.sessionStart({ ...input, clientRestarted: true });
+      // session and generation, and binds again. A client found only now
+      // takes the same path, with the table this turn already read.
+      const started = await HANDLERS.sessionStart({ ...input, clientRestarted: true,
+        ...(lateClient ? { tableRead: Promise.resolve(found) } : {}) });
       const fresh = await loadSessionBinding({ runtimeDir: paths.root,
         harnessSessionId: event.sessionId });
       const offered = await nativeActivationHintFor({ adapter, event,
@@ -809,7 +837,7 @@ export async function runHook({ adapterId, payload, adapters, dataHome, env,
   runtime = defaultRuntime(), budgetMs = DEFAULT_BUDGET_MS,
   readProcessTable = defaultReadProcessTable,
   probeClientVersion = defaultProbeClientVersion,
-  platform = `${process.platform}-${process.arch}` }) {
+  platform = `${process.platform}-${process.arch}`, includeSessions = false }) {
   const deadline = Date.now() + budgetMs;
   const fallback = { stdout: "", exitCode: 0, decision: "allow", sessions: [], deadlineAt: deadline,
     commitOffers: async () => {} };
@@ -827,8 +855,7 @@ export async function runHook({ adapterId, payload, adapters, dataHome, env,
     // below: it starts now, while the store opens. On Windows it is the part
     // of a start that runs another program.
     const tableRead = event.kind !== "sessionStart" || (adapter.client?.command ?? null) === null
-      ? null : Promise.resolve(readProcessTable({ timeoutMs: Math.max(1,
-        Math.min(PROCESS_TABLE_MS, deadline - Date.now() - TABLE_RESERVE_MS)) }));
+      ? null : readClientTable(readProcessTable, adapter, deadline);
     tableRead?.catch(() => {});
     mark("finding the workspace");
     const context = await openContext({ event, adapterId, dataHome, runtime, env, deadline });
@@ -881,11 +908,16 @@ export async function runHook({ adapterId, payload, adapters, dataHome, env,
     };
     delete result.offerInputs;
 
-    mark("reading the status");
-    const status = await context.service.collectStatus({
-      workspaceId: context.descriptor.id });
-    assertHookBudget(deadline);
-    result.sessions = status.participants.filter(p => p.presence !== "offline");
+    // Who is present, for a caller that asks; the hook entry point never does.
+    // Reading it took the whole store a second time on every hook, 0.4 s to 4 s
+    // of the five-second budget in real workspaces (#298).
+    if (includeSessions) {
+      mark("reading the status");
+      const status = await context.service.collectStatus({
+        workspaceId: context.descriptor.id });
+      assertHookBudget(deadline);
+      result.sessions = status.participants.filter(p => p.presence !== "offline");
+    }
     result.service = context.service;
     return result;
   };
@@ -988,8 +1020,8 @@ export async function registerNativeSession({ adapterId, adapters, event: target
  * register those in this workspace. Bounded by one budget and fail-open; the
  * answer lists what was registered and is otherwise informational.
  */
-export async function registerDiscoveredSessions({ adapters, workspaceId, dataHome, env = {},
-  budgetMs = 2_500, runtime, probeClientVersion, platform }) {
+export async function registerDiscoveredSessions({ adapters, loadAdapters, workspaceId, dataHome,
+  env = {}, budgetMs = 2_500, runtime, probeClientVersion, platform }) {
   const deadline = Date.now() + budgetMs;
   const remaining = () => Math.max(0, deadline - Date.now());
   // An adapter that ignores its timeout must not hold status: its answer is
@@ -1001,19 +1033,27 @@ export async function registerDiscoveredSessions({ adapters, workspaceId, dataHo
       .finally(() => clearTimeout(timer));
   };
   const registered = [];
-  let installed;
+  let installed, registry = adapters;
   try {
     installed = new Set((await loadOwnership({ dataHome })).installs.map(entry => entry.adapterId));
   } catch {
     return registered;
   }
-  for (const adapter of Object.values(adapters ?? {})) {
+  // A caller that loads adapters on demand loads only the installed ones (#270),
+  // within the same budget: a loader that fails or has not answered when it runs
+  // out leaves nothing to ask, the answer for a client with no adapter.
+  if (typeof loadAdapters === "function") {
+    const loaded = await withinBudget(() => loadAdapters([...installed]));
+    if (Array.isArray(loaded)) return registered;
+    registry = loaded;
+  }
+  for (const adapter of Object.values(registry ?? {})) {
     if (typeof adapter?.discoverNativeSessions !== "function" || !installed.has(adapter.id)) continue;
     const found = await withinBudget(() => adapter.discoverNativeSessions({ env,
       timeoutMs: remaining() }));
     for (const candidate of Array.isArray(found) ? found : []) {
       if (remaining() === 0) return registered;
-      const result = await registerNativeSession({ adapterId: adapter.id, adapters,
+      const result = await registerNativeSession({ adapterId: adapter.id, adapters: registry,
         event: { sessionId: candidate?.sessionId, cwd: candidate?.cwd }, clientPid: candidate?.clientPid,
         workspaceId, dataHome, env, budgetMs: remaining(),
         ...(runtime ? { runtime } : {}), ...(probeClientVersion ? { probeClientVersion } : {}),

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

@@ -1,11 +1,12 @@
 {
   "name": "@agents-can-communicate/installer",
-  "version": "0.10.4",
+  "version": "0.11.1",
   "private": true,
   "type": "module",
   "exports": {
     ".": "./src/index.mjs",
-    "./hook-support": "./src/hook-support.mjs"
+    "./hook-support": "./src/hook-support.mjs",
+    "./live-policy": "./src/live-policy.mjs"
   },
   "files": [
     "src/"

package/node_modules/@agents-can-communicate/installer/src/apply.mjs

@@ -39,6 +39,7 @@ export async function applyPlan({ plan, adapters, context, dataHome, dryRun = fa
         const createdDirectories = await missingArtifactParents({ home: context.home,
           artifacts: operation.artifacts });
         const installContext = { ...context,
+          indicator: operation.indicator,
           clientVersion: operation.clientVersion, platform: operation.platform,
           requestedLivePolicy: operation.livePolicy ?? "off",
           livePolicy: operation.configuredLivePolicy ?? operation.effectiveLivePolicy ?? "off" };
@@ -71,10 +72,12 @@ export async function applyPlan({ plan, adapters, context, dataHome, dryRun = fa
           version: operation.clientVersion ?? null, accVersion,
           artifacts: operation.artifacts, createdDirectories,
           deliveryPolicy: operation.livePolicy, deliveryDecision: operation.deliveryDecision,
+          indicator: operation.indicator,
           nativeActivation: native });
         results.operations.push({ ...operation, applied: true,
           needsAction: outcome.needsAction ?? [],
           changes: outcome.changes ?? [], diagnostics: [
+            ...(operation.indicatorDiagnostic === undefined ? [] : [operation.indicatorDiagnostic]),
             ...(operation.deliveryDiagnostic === undefined
               ? [] : [operation.deliveryDiagnostic]),
             ...(outcome.diagnostics ?? []),