agents-can-communicate 0.8.3 → 0.8.5

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

@@ -9,6 +9,7 @@ import { stageOwnGeneration } from "./generation.mjs";
 import { writeLaunchers } from "./launchers.mjs";
 import { canonicalManagerRoot, readControl, writeControl } from "./state.mjs";
 import { scheduleWorker } from "./schedule.mjs";
+import { reclaimAsActive } from "./worker.mjs";
 import { releaseStagingHold } from "./staging.mjs";
 import { withManagerLock } from "./mutex.mjs";
 import { retireManagedHolds } from "./retire.mjs";
@@ -36,7 +37,8 @@ export async function installManaged({ packageRoot, managerRoot, dataHome, home,
   // writes below) or abandoned (any throw between here and there).
   try {
     await verifyGeneration(candidate, { env });
-    return await withManagerLock(root, async () => {
+    let ready = null;
+    const installed = await withManagerLock(root, async () => {
       const previous = await readControl(root);
       if (previous !== null && previous.home !== home) {
         throw new Error("this ACC data home manages another client home; use a separate ACC_DATA_HOME");
@@ -67,13 +69,21 @@ export async function installManaged({ packageRoot, managerRoot, dataHome, home,
       const integrationFailed = result.failed.some(failure => failure.stage !== "service-setup"
         || !result.operations?.some(operation => operation.adapterId === failure.adapterId && operation.applied === true));
       if (!integrationFailed) {
-        const ready = await writeControl(root, { ...control, phase: "ready", pending: null });
-        await scheduleWorker(root, ready, { env });
+        ready = await writeControl(root, { ...control, phase: "ready", pending: null });
       } else {
         await writeControl(root, { ...control, notice: "Integration refresh is incomplete; run acc update to recover." });
       }
       return result;
     });
+    if (ready !== null) {
+      // This install runs the code of the generation it activated, so its
+      // reclaim is that generation's rule (#208). It takes the manager lock
+      // itself, hence after the fence; a worker is then started only for work
+      // that is actually due.
+      await reclaimAsActive(root, candidate.root);
+      await scheduleWorker(root, ready, { env });
+    }
+    return installed;
   } finally {
     await releaseStagingHold(candidate.hold);
   }

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

@@ -4,9 +4,27 @@ import { confirmedDead } from "./mutex.mjs";
 import { readManagedJson } from "./state.mjs";
 import { checkDue, networkDisabled } from "./policy.mjs";
 
+// The active generation has not yet reclaimed with its own rule (#208): the
+// worker records `reclaim.json` naming the root it reclaimed as. Local work, so
+// neither the update opt-out nor the no-network override holds it back. An
+// unreadable marker is not a reason to start a worker on every entry.
+// A pass an unknown holder postponed is retried, at most hourly, so a holder
+// that never becomes readable cannot start a worker on every entry.
+const RECLAIM_RETRY_MS = 60 * 60_000;
+async function reclaimDue(root, control) {
+  let marker;
+  try { marker = await readManagedJson(path.join(root, "reclaim.json")); } catch { return false; }
+  if (marker?.activeRoot !== control.active.root) return true;
+  if (marker.complete !== false) return false;
+  const attempted = Date.parse(marker.attemptedAt);
+  return !Number.isFinite(attempted) || Date.now() - attempted >= RECLAIM_RETRY_MS;
+}
+
 /** No network waits here: this only starts an independent background process. */
 export async function scheduleWorker(root, control, { env = process.env } = {}) {
-  if (!control?.auto || networkDisabled(env) || !control.pending && !checkDue(control)) return false;
+  if (!control?.active) return false;
+  const update = control.auto && !networkDisabled(env) && (control.pending || checkDue(control));
+  if (!update && !await reclaimDue(root, control)) return false;
   try {
     for (const directory of [path.join(root, "worker"), path.join(root, "worker", "poller")]) {
       const owner = await readManagedJson(path.join(directory, "manager.lock", "owner.json"));

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

@@ -1,7 +1,11 @@
-import { activatePending } from "./activation.mjs";
+import { realpath } from "node:fs/promises";
+import path from "node:path";
+
+import { activatePending, reclaimGenerations } from "./activation.mjs";
+import { listRuntimeHolds } from "./leases.mjs";
 import { downloadRelease, fetchRelease, newerVersion } from "./download.mjs";
 import { withManagerLock } from "./mutex.mjs";
-import { readControl, writeControl } from "./state.mjs";
+import { readControl, writeControl, writeManagedJson } from "./state.mjs";
 import { releaseStagingHold } from "./staging.mjs";
 import { MAINTENANCE_ACTIVE, maintenanceNotice, maintenanceReport, readMaintenance } from "./maintenance-state.mjs";
 import { requestMaintenance } from "./maintenance.mjs";
@@ -62,8 +66,54 @@ export async function performUpdate(root, { force = false, check = false, env =
   return { ...checked, pending: generation.version, ...await activate(root, { env, ignorePid }) };
 }
 
+/**
+ * Reclaim with this generation's own rule, when it is the active one (#208).
+ *
+ * An update is run by the older installed code, so the reclaim right after an
+ * activation applies the older rule, and a fix to that rule used to take
+ * effect only one release later. The active generation's worker runs this on
+ * its first pass, which the scheduler starts for a generation that has not
+ * recorded it yet, and on every later pass. A reclaim that finds an unknown
+ * holder still postpones itself; the next pass tries again.
+ */
+export const RECLAIM_MARKER = "reclaim.json";
+export async function reclaimAsActive(root, generationRoot) {
+  if (typeof generationRoot !== "string") return;
+  try {
+    const control = await readControl(root);
+    if (control === null || await realpath(generationRoot) !== await realpath(control.active.root)) return;
+    const result = await reclaimGenerations({ root });
+    // The process that activated this generation still runs from the one it
+    // replaced, and its own lease keeps that generation through this pass -
+    // measured in the 0.8.5 upgrade preflight. That pass is unfinished, so the
+    // hourly retry removes the old generation once the process has exited. A
+    // worker started at once would race every command right after an update.
+    const active = await realpath(control.active.root);
+    const own = await listRuntimeHolds(root).then(async holds => {
+      for (const hold of holds) {
+        if (hold.pid === process.pid && await realpath(hold.runtime.root).catch(() => null) !== active) {
+          return true;
+        }
+      }
+      return false;
+    }, () => false);
+    // A postponed pass is recorded as unfinished too, so the scheduler tries
+    // again (hourly) even with automatic updates off.
+    await writeManagedJson(path.join(root, RECLAIM_MARKER), { schemaVersion: 1,
+      activeRoot: control.active.root, complete: result?.postponed !== true && !own,
+      attemptedAt: new Date().toISOString() });
+  } catch { /* Best effort; the next pass reclaims again. */ }
+}
+
 /** One poller may wait; the update lock stays available between its passes. */
-export async function runWorker(root, { force = false, env = process.env, wait = false, ignorePid = null } = {}) {
+export async function runWorker(root, { force = false, env = process.env, wait = false, ignorePid = null,
+  generationRoot = null } = {}) {
+  const result = await pass(root, { force, env, wait, ignorePid });
+  await reclaimAsActive(root, generationRoot);
+  return result;
+}
+
+async function pass(root, { force, env, wait, ignorePid }) {
   const poll = async () => {
     for (;;) {
       const result = await withManagerLock(`${root}/worker`,

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

@@ -43,7 +43,11 @@ export function nativeRemediation(entry) {
   }
   if (native.reasonCode === "native_endpoint_unavailable") {
     if (["blocked", "unsupported"].includes(service?.state)) steps.push(service.diagnostic);
-    else if (service?.state === "needed" && native.configured) {
+    else if (service?.state === "needed" && service.startsOnLaunch === true) {
+      // The client starts it itself when its next session opens.
+      steps.push(`${entry.displayName}: its local delivery service starts with the next `
+        + `${entry.displayName} session; open one, then run acc doctor here`);
+    } else if (service?.state === "needed" && native.configured) {
       steps.push(service.requiresInstall && entry.deliveryDecision?.installPrerequisites === false
         ? `acc install --adapter ${entry.adapterId} --delivery ${native.policy === "all" ? "all" : "actionable"}`
           + "  # allow the official Codex download and complete service setup"

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

@@ -104,6 +104,9 @@ const failures = {
   session_generation_stale: "the session was replaced during the handshake",
   workspace_identity_unavailable: "the bound client session is no longer in this workspace; "
     + "start a new client session here",
+  // It stays embedded until it closes; a later service never adopts it.
+  client_session_embedded: "the client runs this session on its own embedded service, which "
+    + "peers cannot reach; start a new client session while its local delivery service runs",
 };
 
 function describeAttempt(attempt) {
@@ -117,7 +120,10 @@ function describeAttempt(attempt) {
         : attempt.policyStatus === "unavailable" ? `${source} delivery policy could not be read`
           : `${source} delivery policy was off`;
   } else if (attempt.state === "active") detail = "local handshake succeeded";
-  else detail = failures[attempt.reasonCode] ?? describeNativeReason(attempt.reasonCode);
+  else if (attempt.reasonCode === "client_session_embedded" && attempt.launchOption) {
+    detail = `${describeNativeReason(attempt.reasonCode, { launchOption: attempt.launchOption })}; `
+      + `start a new client session without ${attempt.launchOption}`;
+  } else detail = failures[attempt.reasonCode] ?? describeNativeReason(attempt.reasonCode);
   return `last attempt ${attempt.at}: ${detail}`;
 }
 

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

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

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

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

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

@@ -0,0 +1,22 @@
+import { listSessionBindings, loadNativeAttempt } from "@agents-can-communicate/adapter-sdk";
+
+/**
+ * Why a session has no live transport, as its own last native attempt said:
+ * `{ reasonCode, launchOption? }`, the option being the client launch option
+ * that attempt named as the cause.
+ *
+ * The same record `acc doctor` reads, found through the hook-owner file that
+ * names this exact session generation. Null when none says: an attempt that
+ * succeeded, a record for another generation, or no runtime to read.
+ */
+export async function lastNativeReason({ runtimeDir, sessionId, generation }) {
+  if (typeof runtimeDir !== "string") return null;
+  const owners = (await listSessionBindings({ runtimeDir }))
+    .filter(owner => owner.accSessionId === sessionId && owner.generation === generation);
+  if (owners.length !== 1) return null;
+  const attempt = await loadNativeAttempt({ runtimeDir,
+    harnessSessionId: owners[0].harnessSessionId, accSessionId: sessionId, generation });
+  if (attempt === null || attempt.state === "active") return null;
+  return { reasonCode: attempt.reasonCode,
+    ...(attempt.launchOption ? { launchOption: attempt.launchOption } : {}) };
+}

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

@@ -1,5 +1,7 @@
-import { evaluateVersionContract } from "@agents-can-communicate/adapter-sdk";
+import { NATIVE_REASON_CODES, evaluateVersionContract, isLaunchOption }
+  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",
@@ -45,9 +47,23 @@ function safeTransport(value, opaqueEndpointRef) {
   return opaqueEndpointRef === "live-adapter" ? "native-live" : "live-adapter";
 }
 
-export function createDeliveryRouter({ service, adapters, clock, readLivePolicy }) {
+export function createDeliveryRouter({ service, adapters, clock, readLivePolicy,
+  readNativeReason = input => lastNativeReason({ runtimeDir: service.store?.root, ...input }) }) {
   const registry = adaptersById(adapters);
 
+  // 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
+  // client launch option behind it when the attempt named one.
+  async function withoutLiveTransport(participantId, target) {
+    const found = await Promise.resolve()
+      .then(() => readNativeReason({ sessionId: target.sessionId, generation: target.generation }))
+      .catch(() => null);
+    const reason = found?.reasonCode;
+    if (!NATIVE_REASON_CODES.includes(reason)) return durable(participantId, "no_live_transport");
+    return { ...durable(participantId, "no_live_transport"), nativeReasonCode: reason,
+      ...(isLaunchOption(found.launchOption) ? { nativeLaunchOption: found.launchOption } : {}) };
+  }
+
   // Read at offer time, not from the binding: consent withdrawn after a session
   // bound must stop the next offer, not the next rebind.
   async function policyFor(adapter, binding) {
@@ -94,7 +110,7 @@ export function createDeliveryRouter({ service, adapters, clock, readLivePolicy
         && binding.generation === target.generation);
     // Online, with nothing to push through: a CLI participant, or a client
     // that bound no live transport. It reads its inbox, so it is not gone.
-    if (bindings.length === 0) return durable(participantId, "no_live_transport");
+    if (bindings.length === 0) return withoutLiveTransport(participantId, target);
     const evaluated = await Promise.all(bindings.map(async binding => {
       const adapter = registry.get(binding.adapterId);
       return { binding, adapter, policy: await policyFor(adapter, binding) };

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

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

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

@@ -45,6 +45,7 @@ export async function bindNative({ adapter, event, hookBinding, clientVersion, p
         reasonCode: result.reasonCode, policy, policySource, policyStatus,
         clientProcess: Number.isInteger(hookBinding.clientPid) && hookBinding.clientPid > 0
           ? "identified" : "unknown",
+        ...(result.launchOption === undefined ? {} : { launchOption: result.launchOption }),
       } }).catch(() => {});
   }
   return result;
@@ -57,6 +58,7 @@ 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,
+      ...(usableHint(value.userMessage) ? { userMessage: value.userMessage } : {}),
       release: typeof value.release === "function" ? value.release : async () => {} };
   }
   if (value !== null && typeof value === "object" && typeof value.release === "function") {
@@ -66,7 +68,8 @@ function asHint(value) {
 }
 
 function usableHint(line) {
-  return line !== "" && !/[\r\n]/.test(line) && Buffer.byteLength(line, "utf8") <= HINT_MAX_BYTES;
+  return typeof line === "string" && line !== "" && !/[\r\n]/.test(line)
+    && Buffer.byteLength(line, "utf8") <= HINT_MAX_BYTES;
 }
 
 // An adapter may release with a synchronous function. Calling `.catch` on its
@@ -91,6 +94,8 @@ export function callRelease(release) {
  * 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.
+ * `{ line, userMessage }` also asks for a line the user sees and the model
+ * does not, held to the same bound; one that does not fit is dropped alone.
  */
 export async function nativeActivationHintFor({ adapter, event, nativeBinding, binding, context,
   paths, deadline }) {

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

@@ -37,8 +37,11 @@ function discardEndpoint(adapter, handshake, runtimeDir) {
 export async function establishNativeBinding({ adapter, event, hookBinding, clientVersion,
   platform, livePolicy, service, runtimeDir, clock, env,
   timeoutMs = DEFAULT_TIMEOUT_MS, heartbeatCadenceMs = DEFAULT_CADENCE_MS }) {
-  const outcome = (state, reasonCode, modes = []) =>
-    Object.freeze({ state, reasonCode, modes: Object.freeze([...modes]) });
+  // A refusal may name the client launch option behind it; see
+  // validateNativeHandshake, which admits only a bare option token.
+  const outcome = (state, reasonCode, modes = [], launchOption = null) =>
+    Object.freeze({ state, reasonCode, modes: Object.freeze([...modes]),
+      ...(launchOption === null ? {} : { launchOption }) });
   const sessionId = hookBinding?.accSessionId;
   const generation = hookBinding?.generation;
   if (typeof sessionId !== "string" || typeof generation !== "string") return outcome("off", null);
@@ -80,7 +83,7 @@ export async function establishNativeBinding({ adapter, event, hookBinding, clie
     if (!verdict.ok) {
       await discardEndpoint(adapter, handshake, runtimeDir);
       return outcome(STATIC_REASONS.has(verdict.reasonCode) ? "unsupported" : "degraded",
-        verdict.reasonCode);
+        verdict.reasonCode, [], verdict.launchOption ?? null);
     }
     const now = Date.parse(clock.now());
     const lease = Date.parse(verdict.leaseUntil);

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

@@ -5,12 +5,14 @@ import path from "node:path";
 import { fileURLToPath } from "node:url";
 
 import { capabilityEvidence, clearNativeAttempt, clearSessionBinding, effectiveCapabilities,
-  loadSessionBinding, storeSessionBinding }
+  loadSessionBinding, normalizedEvent, storeSessionBinding }
   from "@agents-can-communicate/adapter-sdk";
 import { createCoordinationService } from "@agents-can-communicate/core";
+import { loadOwnership } from "@agents-can-communicate/installer";
 import { AccError, createId } from "@agents-can-communicate/protocol";
 import { openFilesystemStore } from "@agents-can-communicate/storage-filesystem";
-import { clearPin, createGitProbe, resolveHookWorkspace, platformDataHome, runtimePaths, writePin }
+import { clearPin, createGitProbe, resolveHookWorkspace, platformDataHome, runtimePaths,
+  writePin as writeRuntimePin }
   from "@agents-can-communicate/cli";
 
 import { resolveClientPid } from "./client-pid.mjs";
@@ -236,8 +238,8 @@ async function openContext({ event, adapterId, dataHome, runtime, env, deadline
 // offered. Runs after the heartbeat and the bounded native retry.
 // `render` is how the projected text reaches this client: before a turn it is
 // the adapter's context envelope, at the end of one it is a continuation.
-async function projectTurn({ binding, context, adapter, adapterId,
-  render = text => adapter.injectOutcome?.(text), activationHint = null, repeats = true }) {
+async function projectTurn({ binding, context, adapter, adapterId, render = null,
+  activationHint = null, activationNotice = null, repeats = true }) {
   const sync = await context.service.sync({ sessionId: binding.accSessionId,
     cursor: null, scope: "delta" });
 
@@ -281,11 +283,17 @@ async function projectTurn({ binding, context, adapter, adapterId,
   const owner = hintFits ? `${header}\n${activationHint}` : header;
   const withHint = (outcome, attached) => ({ ...outcome,
     activationHintIncluded: attached === true && outcome.stdout !== "" });
+  // The ask's line for the user travels with its line for the model, or not
+  // at all: the adapter shows it where the client shows a hook's message.
+  const notice = hintFits && activationNotice !== null ? { userMessage: activationNotice } : null;
+  const inject = text => notice === null ? adapter.injectOutcome?.(text)
+    : adapter.injectOutcome?.(text, notice);
+  const renderText = render ?? inject;
   // 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 withHint(ownerOnlyOutcome(text => adapter.injectOutcome?.(text), owner, totalBudget),
+    return withHint(ownerOnlyOutcome(inject, owner, totalBudget),
       hintFits);
   }
 
@@ -334,7 +342,7 @@ 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 withHint(ownerOnlyOutcome(text => adapter.injectOutcome?.(text), owner, totalBudget),
+    return withHint(ownerOnlyOutcome(inject, owner, totalBudget),
       hintFits);
   }
   const projected = body === "" ? "" : ownerFits ? `${owner}\n${body}` : body;
@@ -359,7 +367,7 @@ async function projectTurn({ binding, context, adapter, adapterId,
   // The entry point owns the transport boundary. This handler only prepares
   // offer inputs; recording them here would claim delivery before stdout's
   // callback proves that the bytes crossed.
-  const outcome = { stdout: "", ...render(projected) };
+  const outcome = { stdout: "", ...renderText(projected) };
   const writableOffers = outcome.stdout === "" ? [] : offerInputs;
   return withHint({ ...outcome,
     stderr: [outcome.stderr, ownerWarning, degradation].filter(Boolean).join("\n"),
@@ -371,7 +379,8 @@ async function projectTurn({ binding, context, adapter, adapterId,
 // so the reservation goes with it.
 async function projectActivation(input, offered) {
   try {
-    const turn = await projectTurn({ ...input, activationHint: offered?.line ?? null });
+    const turn = await projectTurn({ ...input, activationHint: offered?.line ?? null,
+      activationNotice: offered?.userMessage ?? null });
     const included = turn.activationHintIncluded === true;
     delete turn.activationHintIncluded;
     if (!offered) return turn;
@@ -388,11 +397,16 @@ async function projectActivation(input, offered) {
 }
 
 const HANDLERS = {
+  // `knownClientPid` and `pins: false` are registration's (#167): it runs in
+  // a peer's process, so the client's pid is handed over rather than found in
+  // this process's ancestry, and it pins nothing because no hook code of any
+  // generation runs for the session until its first real hook pins its own.
   async sessionStart({ event, context, adapter, adapterId, binding, paths,
-    readProcessTable, probeClientVersion, platform, deadline }) {
+    readProcessTable, probeClientVersion, platform, deadline, knownClientPid, pins = true }) {
     // Where this session's pin lives, resolved once and reused at every write
     // below. Beside `paths.root`, never inside it: see `managerRootFor`.
     const pinRoot = managerRootFor(context.dataHome);
+    const writePin = pins === false ? async () => {} : writeRuntimePin;
     // A repeated start refreshes the client's version/platform. Remove the old
     // certified facts before any probe, PID lookup, resume, or open can fail;
     // keep only the generation identity needed for a successful resume.
@@ -414,7 +428,8 @@ const HANDLERS = {
     // null, and the session is then judged by age alone - which is exactly the
     // behaviour every session had before this existed.
     const command = adapter.client?.command ?? null;
-    const pid = command === null ? null
+    const pid = Number.isInteger(knownClientPid) && knownClientPid > 0 ? knownClientPid
+      : command === null ? null
       : resolveClientPid({ table: await readProcessTable({
         timeoutMs: Math.max(1, Math.min(1_000, deadline - Date.now())) }), from: process.pid, command });
     assertHookBudget(deadline);
@@ -767,3 +782,101 @@ export async function runHook({ adapterId, payload, adapters, dataHome, env,
     clearTimeout(timer);
   }
 }
+
+/**
+ * Register a client session before its first turn (#167).
+ *
+ * Exactly what SessionStart writes - binding, session, native binding and its
+ * diagnostic - under the same per-session lifecycle lock, so the chat's first
+ * real hook finds the binding and resumes this session instead of opening a
+ * second one. The caller is a peer's process, so the client's pid is handed
+ * over, the caller's own ACC_PARTICIPANT never names the chat, and nothing is
+ * pinned or printed. A session that already has a binding is left alone.
+ * Never throws: status must not fail because of it.
+ */
+export async function registerNativeSession({ adapterId, adapters, event: target, clientPid,
+  workspaceId, dataHome, env = {}, runtime = defaultRuntime(), budgetMs = DEFAULT_BUDGET_MS,
+  probeClientVersion = defaultProbeClientVersion, platform = `${process.platform}-${process.arch}` }) {
+  const deadline = Date.now() + budgetMs;
+  const skipped = reason => ({ registered: false, reason });
+  const register = async () => {
+    const adapter = adapters?.[adapterId];
+    if (adapter === undefined || !Number.isInteger(clientPid) || clientPid <= 0) return skipped("unsupported");
+    const event = normalizedEvent({ kind: "sessionStart", sessionId: target?.sessionId, cwd: target?.cwd });
+    const { ACC_PARTICIPANT: _callerName, ...hostEnv } = env;
+    const context = await openContext({ event, adapterId, dataHome, runtime, env: hostEnv, deadline });
+    if (workspaceId !== undefined && context.descriptor.id !== workspaceId) return skipped("other_workspace");
+    return withSessionLifecycle({ root: context.paths.root, sessionId: event.sessionId,
+      clock: runtime.clock, deadlineAt: deadline }, async () => {
+      // As in runHook: recover a write a previous holder journalled before
+      // interpreting the binding.
+      const store = await openFilesystemStore({ root: context.paths.root, clock: runtime.clock,
+        ids: runtime.ids, workspaceId: context.descriptor.id, deadlineAt: deadline });
+      context.service = createCoordinationService({ store, clock: runtime.clock, ids: runtime.ids });
+      if (await loadSessionBinding({ runtimeDir: context.paths.root,
+        harnessSessionId: event.sessionId }) !== null) return skipped("known");
+      const started = await HANDLERS.sessionStart({ event, context, adapter, adapterId, binding: null,
+        paths: context.paths, readProcessTable: async () => new Map(), probeClientVersion,
+        platform, deadline, knownClientPid: clientPid, pins: false });
+      const session = await context.service.locateSession(started.accSessionId);
+      return { registered: true, sessionId: started.accSessionId,
+        participantId: session?.record.participantId ?? null, workspaceId: context.descriptor.id,
+        nativeBinding: started.nativeBinding };
+    });
+  };
+  let timer;
+  try {
+    return await Promise.race([register(), new Promise(resolve => {
+      timer = setTimeout(() => resolve(skipped("timed_out")), Math.max(0, deadline - Date.now()));
+    })]);
+  } catch {
+    return skipped("failed");
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/**
+ * What a peer runs before it reads status (#167): ask every installed adapter
+ * that can see its client's sessions for the ones ACC could register, and
+ * 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 }) {
+  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
+  // raced against what is left of the budget, and a late one is dropped.
+  const withinBudget = work => {
+    let timer;
+    return Promise.race([Promise.resolve().then(work).catch(() => []),
+      new Promise(resolve => { timer = setTimeout(resolve, remaining(), []); })])
+      .finally(() => clearTimeout(timer));
+  };
+  const registered = [];
+  let installed;
+  try {
+    installed = new Set((await loadOwnership({ dataHome })).installs.map(entry => entry.adapterId));
+  } catch {
+    return registered;
+  }
+  for (const adapter of Object.values(adapters ?? {})) {
+    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,
+        event: { sessionId: candidate?.sessionId, cwd: candidate?.cwd }, clientPid: candidate?.clientPid,
+        workspaceId, dataHome, env, budgetMs: remaining(),
+        ...(runtime ? { runtime } : {}), ...(probeClientVersion ? { probeClientVersion } : {}),
+        ...(platform ? { platform } : {}) });
+      if (result.registered) {
+        registered.push({ adapterId: adapter.id, participantId: result.participantId,
+          sessionId: result.sessionId });
+      }
+    }
+  }
+  return registered;
+}

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/installer",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -1,3 +1,5 @@
+import { isLaunchOption } from "@agents-can-communicate/adapter-sdk";
+
 // Shared presentation of observed delivery facts. Vendor probes provide closed
 // reasons; installation and doctor must not turn a version floor into readiness.
 const REASONS = Object.freeze({
@@ -12,12 +14,20 @@ const REASONS = Object.freeze({
   probe_version_mismatch: "the local service and CLI versions differ",
   protocol_mismatch: "the local service did not confirm the required protocol",
   unsupported_shell: "automatic launch setup requires zsh",
+  client_session_embedded: "the client runs this session on its own embedded service, which peers "
+    + "cannot reach",
 });
 
-export function describeNativeReason(reason, { clientVersion, minimumVersion } = {}) {
+export function describeNativeReason(reason, { clientVersion, minimumVersion, launchOption } = {}) {
   if (reason === "below_minimum_version" && clientVersion && minimumVersion) {
     return `client ${clientVersion} needs version ${minimumVersion} or newer for native delivery`;
   }
+  // A client can run embedded because of how it was started - Codex does for
+  // `--search`, `-c`, `--profile` and others while its daemon runs.
+  if (reason === "client_session_embedded" && isLaunchOption(launchOption)) {
+    return `the client was started with ${launchOption}, which runs this session on its own `
+      + "embedded service that peers cannot reach";
+  }
   return REASONS[reason] ?? reason ?? "readiness is unverified";
 }
 export const describeDeliveryFallback = entry => entry.capabilities?.delivery?.nextTurn === true

package/node_modules/@agents-can-communicate/mcp-server/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/mcp-server",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "private": true,
   "type": "module",
   "exports": {

package/node_modules/@agents-can-communicate/mcp-server/src/server.mjs

@@ -118,6 +118,9 @@ async function callTool(name, args, context) {
 
   switch (name) {
     case "acc_status":
+      // Chats a client holds before their first turn, registered so this
+      // caller can address them (#167). Fail-open: status is read regardless.
+      await Promise.resolve().then(() => context.registerNativeSessions?.()).catch(() => null);
       return service.collectStatus({});
     case "acc_sync":
       return service.sync({ ...owner, cursor: args.cursor ?? null,

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-can-communicate",
-  "version": "0.8.3",
+  "version": "0.8.5",
   "accManagedUpdateProtocol": 2,
   "accStoreVersion": 6,
   "type": "module",