agents-can-communicate 0.11.0 → 0.11.1

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

@@ -5,10 +5,6 @@
 import { AccError, CONFIG_FILENAME, EXIT, GENERIC_MESSAGE_KINDS, VALID_OBLIGATIONS,
   failure, ok }
   from "@agents-can-communicate/protocol";
-import { createCoordinationService } from "@agents-can-communicate/core";
-import { shellQuote } from "@agents-can-communicate/adapter-sdk";
-import { describeNativeReason } from "@agents-can-communicate/installer";
-import { openFilesystemStore } from "@agents-can-communicate/storage-filesystem";
 
 import { parseArgs, positiveNumber } from "./args.mjs";
 
@@ -16,18 +12,10 @@ import { parseArgs, positiveNumber } from "./args.mjs";
 // with the argument already half-applied.
 const usage = message => new AccError(EXIT.USAGE, message);
 import { commandHelpText, describeCommand, describeCommands, helpText } from "./help.mjs";
-import { runUpdateCommand } from "./update-command.mjs";
-import { runConfigCommand } from "./config-command.mjs";
-import { ALL_ADAPTERS, runInstallCommand } from "./install-command.mjs";
-import { runDoctor } from "./doctor-command.mjs";
-import { runManagementDoctor } from "./managed-runtime/diagnostics.mjs";
-import { runStoreMigration } from "./store-migration-command.mjs";
+import { loadAdapters } from "./adapter-catalog.mjs";
 import { createGitProbe } from "./git-probe.mjs";
-import { runClaimCommand, runReleaseCommand } from "./claim-command.mjs";
 import { platformDataHome, runtimePaths } from "./runtime-paths.mjs";
 import { resolveOwner } from "./session-owner.mjs";
-import { discoverWorkspace } from "./workspace-discovery.mjs";
-import { resolveSavedHookWorkspace } from "./hook-workspace.mjs";
 
 const DEFAULT_CADENCE_MS = 30_000;
 
@@ -39,6 +27,10 @@ const DEFAULT_CADENCE_MS = 30_000;
  * looking is safe.
  */
 async function locateContext(options, runtime) {
+  // Workspace discovery reads through the store's no-follow opens, so it is
+  // loaded by the commands that use a workspace, never by `version` (#270).
+  const [{ discoverWorkspace }, { resolveSavedHookWorkspace }] = await Promise.all([
+    import("./workspace-discovery.mjs"), import("./hook-workspace.mjs")]);
   const dataHome = runtime.dataHome ?? platformDataHome({ platform: runtime.platform,
     env: runtime.env });
   const discovery = {
@@ -59,6 +51,10 @@ async function locateContext(options, runtime) {
 }
 
 async function withService({ descriptor, paths, dataHome }, runtime) {
+  // Loaded here rather than at the top: `version`, `help` and the commands
+  // that work on a machine never open a store (#270).
+  const [{ openFilesystemStore }, { createCoordinationService }] = await Promise.all([
+    import("@agents-can-communicate/storage-filesystem"), import("@agents-can-communicate/core")]);
   const store = await openFilesystemStore({ root: paths.root, clock: runtime.clock,
     ids: runtime.ids, workspaceId: descriptor.id });
   const service = createCoordinationService({ store, clock: runtime.clock, ids: runtime.ids });
@@ -120,35 +116,10 @@ function obligationFor(kind, explicit, addressed) {
   return obligation;
 }
 
-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; retry the same command "
-          + "through approved execution"
-          + (typeof message.clientMessageId === "string"
-            ? ` with --client-message-id ${shellQuote(message.clientMessageId)}` : " with its original retry key")
-        : item.errorCode === "no_live_transport"
-          ? `${item.recipientParticipantId} has no live transport`
-            + `${item.nativeReasonCode ? ` (${describeNativeReason(item.nativeReasonCode,
-              { launchOption: item.nativeLaunchOption })})` : ""}`
-            + "; 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("; ");
-}
+// What a sent message met, in words. Its diagnostics load with the first
+// message a command sends, not with `acc version` (#270).
+const describeRecorded = async (message, delivery) =>
+  (await import("./recorded-text.mjs")).recordedText(message, delivery);
 
 export async function recordAndOffer({ record, router, selectMessage = value => value }) {
   const recorded = await record();
@@ -179,7 +150,7 @@ export async function recordAndOffer({ record, router, selectMessage = value =>
  * A live binding wakes on the router's own rule: a current lease, or a lapsed
  * one the adapter can re-verify. Without that the next send is durable.
  */
-export function presenceBreakdown(participants = [], adapters = ALL_ADAPTERS()) {
+export function presenceBreakdown(participants = [], adapters = []) {
   const nextTurn = new Set(adapters.filter(adapter => adapter.capabilities?.delivery?.nextTurn === true)
     .map(adapter => adapter.id));
   const refreshes = new Set(adapters.filter(adapter => typeof adapter.refreshNativeSession === "function")
@@ -212,13 +183,13 @@ export function describePresence({ live = 0, stale = 0 } = {},
   return `${live} live (${parts.join("; ")})`;
 }
 
-export function describeStatus(status) {
+export function describeStatus(status, adapters = []) {
   // `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, presenceBreakdown(status.participants))}; `
+  const line = `${describePresence(status.counts, presenceBreakdown(status.participants, adapters))}; `
     + `${status.counts.claims} claim(s); `
     + `protection ${status.protection}`;
   // A transport accepting a message is not a model reading it. Said only when
@@ -294,8 +265,8 @@ const HANDLERS = Object.freeze({
     return { data: intent, text: `intent: ${intent.summary}` };
   },
 
-  claim: runClaimCommand,
-  release: runReleaseCommand,
+  claim: async input => (await import("./claim-command.mjs")).runClaimCommand(input),
+  release: async input => (await import("./claim-command.mjs")).runReleaseCommand(input),
 
   message: async ({ options, context }) => {
     const kind = options.type ?? "note";
@@ -310,7 +281,7 @@ const HANDLERS = Object.freeze({
       subject: options.subject, body: options.body, descriptor: context.descriptor }) });
     const message = routed.recorded;
     return { data: { message, delivery: routed.delivery },
-      text: recordedText(message, routed.delivery) };
+      text: await describeRecorded(message, routed.delivery) };
   },
 
   inbox: async ({ options, context }) => {
@@ -337,7 +308,7 @@ const HANDLERS = Object.freeze({
       subject: options.subject, clientMessageId: clientMessageId(options, context) }) });
     const result = routed.recorded;
     return { data: { message: result.reply, receipt: result.receipt, delivery: routed.delivery },
-      text: `${recordedText(result.reply, routed.delivery)}; acknowledged ${result.receipt.messageId}` };
+      text: `${await describeRecorded(result.reply, routed.delivery)}; acknowledged ${result.receipt.messageId}` };
   },
 
   request: async ({ options, context }) => {
@@ -355,7 +326,7 @@ const HANDLERS = Object.freeze({
     }) });
     const message = routed.recorded;
     return { data: { message, delivery: routed.delivery },
-      text: recordedText(message, routed.delivery) };
+      text: await describeRecorded(message, routed.delivery) };
   },
 
   ack: async ({ options, context }) => {
@@ -374,17 +345,20 @@ const HANDLERS = Object.freeze({
       remaining: options.remaining ?? [], blockers: options.blocker ?? [] }) });
     const handoff = routed.recorded;
     return { data: { message: handoff.message, delivery: routed.delivery },
-      text: recordedText(handoff.message, routed.delivery) };
+      text: await describeRecorded(handoff.message, routed.delivery) };
   },
 
   status: async ({ options, context, runtime }) => {
     await registerNativeSessions(runtime, context);
     const status = await context.service.collectStatus({
       participantId: options.participant, all: options.all === true });
-    return { data: status, text: describeStatus(status) };
+    // Only the clients present here say how their idle sessions are reached.
+    const adapters = await loadAdapters((status.participants ?? []).map(item => item.harness));
+    return { data: status, text: describeStatus(status, Object.values(adapters)) };
   },
 
   config: async ({ options, runtime }) => {
+    const { runConfigCommand } = await import("./config-command.mjs");
     const result = await runConfigCommand({ subcommand: options.subcommand,
       cwd: options.cwd ?? runtime.cwd,
       // A pipe is not a person. Without a TTY there is nobody to answer, so the
@@ -411,11 +385,11 @@ const HANDLERS = Object.freeze({
       text: result.written ? `wrote ${result.file}` : `not written: ${result.file}` };
   },
 
-  install: async ({ options, runtime }) =>
-    runInstallCommand({ options, runtime, action: "install" }),
+  install: async ({ options, runtime }) => (await import("./install-command.mjs"))
+    .runInstallCommand({ options, runtime, action: "install" }),
 
-  uninstall: async ({ options, runtime }) =>
-    runInstallCommand({ options, runtime, action: "uninstall" }),
+  uninstall: async ({ options, runtime }) => (await import("./install-command.mjs"))
+    .runInstallCommand({ options, runtime, action: "uninstall" }),
 
   prune: async ({ options, context }) => {
     const result = await context.service.prune({
@@ -435,9 +409,12 @@ const HANDLERS = Object.freeze({
     return { data: result, text };
   },
 
-  doctor: async input => input.options.migrateStore ? runStoreMigration(input) : runDoctor(input),
+  doctor: async input => input.options.migrateStore
+    ? (await import("./store-migration-command.mjs")).runStoreMigration(input)
+    : (await import("./doctor-command.mjs")).runDoctor(input),
 
-  update: async ({ options, runtime }) => runUpdateCommand({ options, runtime }),
+  update: async ({ options, runtime }) => (await import("./update-command.mjs"))
+    .runUpdateCommand({ options, runtime }),
 
   help: async ({ options }) => {
     if (options.helpCommand === undefined) {
@@ -499,8 +476,9 @@ export async function main(argv, runtime) {
     const options = context === null ? parsed.options
       : await resolveOwner({ command: parsed.command, options: parsed.options,
         context, env: runtime.env });
-    const { data, text, error: outcome } = await (managementDoctor ? runManagementDoctor : HANDLERS[parsed.command])(
-      { options, context, runtime });
+    const handler = managementDoctor
+      ? (await import("./managed-runtime/diagnostics.mjs")).runManagementDoctor : HANDLERS[parsed.command];
+    const { data, text, error: outcome } = await handler({ options, context, runtime });
     // A handler may have done real work and still failed: `acc install` writes
     // for the clients it could and reports the one it could not. The data is
     // printed either way, and the command still fails.

package/node_modules/@agents-can-communicate/cli/src/native-session-diagnostics.mjs

@@ -99,7 +99,7 @@ export async function updateNativeSessions(adapters, { service, status, root, no
 const failures = {
   transport_permission_denied: "this command cannot access the local delivery channel; "
     + "check the sender's command permissions",
-  client_process_unknown: "the client process could not be identified; start a new client session",
+  client_process_unknown: "the client process could not be identified; the next prompt looks for it again",
   handshake_failed: "the session handshake failed; check the client's integration/channel setup",
   handshake_timeout: "the session handshake timed out; check the local channel and retry on the next turn",
   // Since the contract gate shipped, this reason means the version now serving

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

@@ -0,0 +1,32 @@
+import { shellQuote } from "@agents-can-communicate/adapter-sdk";
+import { describeNativeReason } from "@agents-can-communicate/installer";
+
+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; retry the same command "
+          + "through approved execution"
+          + (typeof message.clientMessageId === "string"
+            ? ` with --client-message-id ${shellQuote(message.clientMessageId)}` : " with its original retry key")
+        : item.errorCode === "no_live_transport"
+          ? `${item.recipientParticipantId} has no live transport`
+            + `${item.nativeReasonCode ? ` (${describeNativeReason(item.nativeReasonCode,
+              { launchOption: item.nativeLaunchOption })})` : ""}`
+            + "; 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("; ");
+}

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

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

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.11.0",
+  "version": "0.11.1",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -45,9 +45,12 @@ 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.
@@ -119,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));

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/hook-runner",
-  "version": "0.11.0",
+  "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.11.0",
+  "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/mcp-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/mcp-server",
-  "version": "0.11.0",
+  "version": "0.11.1",
   "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.11.0",
+  "version": "0.11.1",
   "private": true,
   "type": "module",
   "exports": {