agents-can-communicate 0.8.3 → 0.8.4

package/node_modules/@agents-can-communicate/adapter-codex/src/service-setup.mjs

@@ -1,5 +1,6 @@
 import { lstat, realpath } from "node:fs/promises";
 import path from "node:path";
+import { compareVersions } from "./app-server-client.mjs";
 import { readySocketPath, socketIsReady } from "./native-endpoint.mjs";
 import { probeNativeDelivery } from "./native-delivery.mjs";
 import { installCodexStandalone } from "./standalone-install.mjs";
@@ -13,6 +14,9 @@ const keys = ["home", "codexHome", "cliPath", "cliVersion", "managedPath", "mana
 const prerequisiteKeys = ["home", "codexHome", "cliPath", "cliVersion", "cliIdentity", "socketPath", "pidPath", "platform"];
 const same = (a, b, fields = keys) => fields.every(key => a?.[key] === b?.[key]);
 const own = info => typeof process.getuid !== "function" || info.uid === process.getuid();
+// The first CLI measured installing the daemon's own package in a home that
+// has none (2026-09-26; again on 0.159.0, 2026-09-29).
+const SELF_INSTALL_MINIMUM = "0.157.1";
 const sessionNeeded = "Codex service ready; open a new Codex session to establish its delivery binding and review client hooks and permissions";
 const diagnostics = {
   native_endpoint_unavailable: "Prepare the missing Codex service with codex app-server daemon start, then open a new Codex session",
@@ -26,13 +30,25 @@ const diagnostics = {
   managed_binary_mismatch: "Codex CLI and managed standalone versions differ; repair the vendor installation, then retry acc install",
   maintenance_cli_unsupported: "Codex cold service preparation requires codex-cli 0.154.0 or newer with daemon commands; update the vendor installation, then retry acc install",
 };
+const startsOnLaunch = "The Codex service is not running; Codex starts it with the next Codex session "
+  + "(daemon_auto_start), so open Codex, or run acc install to start it now";
 function report(state, reasonCode, facts = {}) {
   return { ...facts, state, reasonCode, diagnostic: state === "ready"
     ? reasonCode === "native_session_unavailable" ? sessionNeeded
       : "Codex service infrastructure is ready; current session binding is reported separately"
+    : facts.startsOnLaunch === true ? startsOnLaunch
     : diagnostics[reasonCode] ?? `Codex service preparation could not verify ${reasonCode}; inspect the vendor service and retry acc install` };
 }
 
+// Since 0.157.1 a TUI that finds no service starts one (`daemon_auto_start`,
+// stable and on by default). `codex features list` reports the effective value
+// after config and profiles; any other answer leaves the start to acc install.
+const AUTO_START = /^daemon_auto_start\s+\S+\s+true\s*$/m;
+async function launchStart(run, paths, facts) {
+  const listed = await run(facts.cliPath, ["features", "list"], paths.options).catch(() => null);
+  return listed?.status === 0 && AUTO_START.test(listed.stdout) ? { startsOnLaunch: true } : {};
+}
+
 export function createCodexServiceSetup({ run = runMaintenanceCommand, probe = probeNativeDelivery,
   fs = { lstat, realpath }, contextPaths = maintenanceContext,
   installStandalone = installCodexStandalone } = {}) {
@@ -90,9 +106,43 @@ export function createCodexServiceSetup({ run = runMaintenanceCommand, probe = p
     const installation = await probeMaintenanceCli({ ...paths,
       options: { ...paths.options, cwd: paths.options.env.HOME } }, run);
     const cli = await executableIdentity(installation.cliPath);
-    return report("needed", "managed_install_missing", { requiresInstall: true,
-      home: paths.options.env.HOME, codexHome: paths.codexHome, cliIdentity: cli.identity,
-      socketPath: paths.socketPath, pidPath: paths.pidPath, platform: paths.platform, ...installation });
+    const facts = { home: paths.options.env.HOME, codexHome: paths.codexHome, cliIdentity: cli.identity,
+      socketPath: paths.socketPath, pidPath: paths.pidPath, platform: paths.platform, ...installation };
+    // A CLI that installs the daemon's own package at its first start needs
+    // no standalone download: starting the service is the whole setup (#205).
+    if (compareVersions(installation.cliVersion, SELF_INSTALL_MINIMUM) >= 0) {
+      return report("needed", "native_endpoint_unavailable", { ...facts, selfInstall: true,
+        ...await launchStart(run, paths, facts) });
+    }
+    return report("needed", "managed_install_missing", { requiresInstall: true, ...facts });
+  }
+  // The service a self-installing CLI prepares: start it, then verify the
+  // package and daemon it installed exactly as an existing one is verified.
+  async function startSelfInstalling(context, plan) {
+    let started = false;
+    try {
+      if (plan.state !== "needed" || !prerequisiteKeys.every(key => typeof plan[key] === "string")) {
+        failMaintenance("invalid_service_setup_plan");
+      }
+      const current = await inspect(context, { strict: true });
+      if (current.state !== "needed" || current.selfInstall !== true || !same(plan, current, prerequisiteKeys)) {
+        failMaintenance("service_identity_changed");
+      }
+      started = true;
+      const result = await run(plan.cliPath, ["app-server", "daemon", "start"], {
+        cwd: plan.codexHome, env: { ...(context?.env ?? process.env), HOME: plan.home, CODEX_HOME: plan.codexHome },
+        timeout: 15_000,
+      });
+      if (result.status !== 0) failMaintenance("daemon_start_failed");
+      const paths = await contextPaths(context);
+      const facts = await installed(paths);
+      if (!same(plan, facts, ["codexHome", "cliPath", "cliVersion", "cliIdentity", "socketPath"])) {
+        failMaintenance("service_identity_changed");
+      }
+      return { ...await verify(paths, facts), started };
+    } catch (error) {
+      return { ...report(started ? "failed" : "blocked", error.reasonCode ?? "daemon_start_failed"), started };
+    }
   }
   async function verify(paths, facts) {
     if (!await readySocketPath(paths.socketPath)) failMaintenance("daemon_socket_unproven");
@@ -129,9 +179,12 @@ export function createCodexServiceSetup({ run = runMaintenanceCommand, probe = p
       if (!await info(paths.managedPath)) return await missingPrerequisite(paths);
       const facts = await installed(paths);
       if (!await info(paths.socketPath) && !await info(paths.pidPath)) {
-        return report("needed", "native_endpoint_unavailable", facts);
+        return report("needed", "native_endpoint_unavailable",
+          { ...facts, ...await launchStart(run, paths, facts) });
+      }
+      if (await serviceStopped(paths)) {
+        return report("needed", "service_stopped", { ...facts, ...await launchStart(run, paths, facts) });
       }
-      if (await serviceStopped(paths)) return report("needed", "service_stopped", facts);
       return await verify(paths, facts);
     } catch (error) {
       const reason = error.reasonCode ?? "service_inspection_failed";
@@ -165,6 +218,7 @@ export function createCodexServiceSetup({ run = runMaintenanceCommand, probe = p
   }
   async function prepareNativeServiceSetup({ context, plan, installPrerequisites, download } = {}) {
     if (plan?.requiresInstall === true) return preparePrerequisite(context, plan, installPrerequisites, download);
+    if (plan?.selfInstall === true) return startSelfInstalling(context, plan);
     let started = false;
     try {
       if (plan?.state === "ready") {

package/node_modules/@agents-can-communicate/adapter-gemini-cli/extension/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-can-communicate",
-  "version": "0.8.3",
+  "version": "0.8.4",
   "description": "Coordinate this Gemini CLI session with other AI agent sessions working in the same workspace.",
   "contextFileName": "skills/acc/SKILL.md"
 }

package/node_modules/@agents-can-communicate/adapter-gemini-cli/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/adapter-gemini-cli",
-  "version": "0.8.3",
+  "version": "0.8.4",
   "private": true,
   "type": "module",
   "exports": {

package/node_modules/@agents-can-communicate/adapter-grok/package.json

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

package/node_modules/@agents-can-communicate/adapter-kimi/package.json

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

package/node_modules/@agents-can-communicate/adapter-sdk/package.json

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

package/node_modules/@agents-can-communicate/adapter-sdk/src/native-vocabulary.mjs

@@ -34,6 +34,9 @@ export const NATIVE_REASON_CODES = Object.freeze([
   // The current session's canonical workspace identity could not be verified.
   // This is a per-session refusal, not a universal vendor limitation.
   "workspace_identity_unavailable",
+  // The client runs this session on its own embedded service, which no sender
+  // can reach, instead of the shared local one; it stays so until it closes.
+  "client_session_embedded",
 ]);
 
 export const STABLE_VERSION = /^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:\+[0-9A-Za-z.-]+)?$/;

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

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

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

@@ -12,7 +12,7 @@ export { describeNative } from "./native-delivery-status.mjs";
 import { nativeSessionLines, updateNativeSessions } from "./native-session-diagnostics.mjs";
 import { ALL_ADAPTERS, clientContext, probeTimeout } from "./install-command.mjs";
 import { decisionOf } from "./install-delivery-consent.mjs";
-import { describePresence, presenceBreakdown } from "./main.mjs";
+import { describePresence, presenceBreakdown, registerNativeSessions } from "./main.mjs";
 import { platformPaths } from "./platform-paths.mjs";
 import { noticeUpdate } from "./update-check.mjs";
 import { managedUpdateDiagnostic } from "./managed-runtime/diagnostics.mjs";
@@ -233,6 +233,7 @@ export async function runDoctor({ options, context, runtime }) {
   // context built for this command opens the store on request rather than up
   // front.
   const service = context.service ?? await context.openService();
+  await registerNativeSessions(runtime, context);
   const status = await service.collectStatus({});
   updateNativeRuntime(adapters, status.deliveryBindings);
   // The runtime state above is read from the binding records alone. The

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

@@ -6,6 +6,7 @@ import { AccError, CONFIG_FILENAME, EXIT, GENERIC_MESSAGE_KINDS, VALID_OBLIGATIO
   failure, ok }
   from "@agents-can-communicate/protocol";
 import { createCoordinationService } from "@agents-can-communicate/core";
+import { describeNativeReason } from "@agents-can-communicate/installer";
 import { openFilesystemStore } from "@agents-can-communicate/storage-filesystem";
 
 import { parseArgs, positiveNumber } from "./args.mjs";
@@ -102,6 +103,18 @@ async function openContext(options, runtime) {
   return withService(await locateContext(options, runtime), runtime);
 }
 
+/**
+ * Before a peer reads status, chats its clients hold but ACC has not seen yet
+ * are registered, so the peer can address them before their first turn
+ * (#167). Bounded and fail-open inside the port; status never waits on it
+ * beyond its budget or fails because of it.
+ */
+export async function registerNativeSessions(runtime, context) {
+  if (typeof runtime?.registerNativeSessions !== "function") return [];
+  return Promise.resolve().then(() => runtime.registerNativeSessions({
+    workspaceId: context.descriptor.id, dataHome: context.dataHome })).catch(() => []);
+}
+
 /**
  * A context for the one command that has to survive an unopenable store.
  *
@@ -150,7 +163,9 @@ export function recordedText(message, delivery) {
       ? item.errorCode === "transport_permission_denied"
         ? "live offer blocked by sender permissions; message remains queued; run acc doctor in the sending session"
         : item.errorCode === "no_live_transport"
-          ? `${item.recipientParticipantId} has no live transport; the message waits in its inbox`
+          ? `${item.recipientParticipantId} has no live transport`
+            + `${item.nativeReasonCode ? ` (${describeNativeReason(item.nativeReasonCode)})` : ""}`
+            + "; 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"
@@ -406,7 +421,8 @@ const HANDLERS = Object.freeze({
       text: recordedText(handoff.message, routed.delivery) };
   },
 
-  status: async ({ options, context }) => {
+  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) };

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

@@ -154,6 +154,10 @@ async function resolveCandidate(value) {
  * Takes its own manager lock, so a caller already holding one (activation)
  * must call this only after releasing it.
  */
+// An unknown holder postpones the whole pass; callers that record having
+// reclaimed need to tell that from a pass that found nothing to remove.
+const POSTPONED = Object.freeze({ removed: [], postponed: true });
+
 export async function reclaimGenerations({ root, active = null, pidIsAlive = defaultPidIsAlive } = {}) {
   root = await canonicalManagerRoot(root);
   return withManagerLock(root, async () => {
@@ -186,19 +190,19 @@ export async function reclaimGenerations({ root, active = null, pidIsAlive = def
     // readControl already throws on, and every real caller of this function
     // treats that throw as reason to postpone. Match that here explicitly:
     // an absent control.json is not proof there is nothing to protect.
-    if (control === null) return { removed: [] };
+    if (control === null) return POSTPONED;
     const referenced = new Set();
     for (const candidate of [active, control.active.root, control.pending?.root]) {
       const resolved = await resolveCandidate(candidate);
-      if (!resolved.ok) return { removed: [] };
+      if (!resolved.ok) return POSTPONED;
       if (resolved.root) referenced.add(resolved.root);
     }
     let holds;
     try { holds = await listRuntimeHolds(root, { pidIsAlive }); }
-    catch { return { removed: [] }; } // An unreadable lease is an unknown holder.
+    catch { return POSTPONED; } // An unreadable lease is an unknown holder.
     for (const lease of holds) {
       const resolved = await resolveCandidate(lease.runtime?.root);
-      if (!resolved.ok) return { removed: [] };
+      if (!resolved.ok) return POSTPONED;
       if (resolved.root) referenced.add(resolved.root);
     }
     // A client that exits without a clean session end leaves its pin behind;
@@ -212,9 +216,9 @@ export async function reclaimGenerations({ root, active = null, pidIsAlive = def
         const record = await readManagedJson(path.join(pins, name)).catch(() => null);
         if (record === undefined) continue; // Concurrent pin removal, not a holder.
         if (!record || record.schemaVersion !== 1 || typeof record.runtimeRoot !== "string"
-          || record.runtimeRoot === "") return { removed: [] }; // Malformed pin: unknown holder.
+          || record.runtimeRoot === "") return POSTPONED; // Malformed pin: unknown holder.
         const resolved = await resolveCandidate(record.runtimeRoot);
-        if (!resolved.ok) return { removed: [] };
+        if (!resolved.ok) return POSTPONED;
         referenced.add(resolved.root);
       }
     }
@@ -231,9 +235,9 @@ export async function reclaimGenerations({ root, active = null, pidIsAlive = def
         const record = await readManagedJson(path.join(staging, name)).catch(() => null);
         if (record === undefined) continue; // Concurrent hold release, not a holder.
         if (!record || record.schemaVersion !== 1 || typeof record.generationRoot !== "string"
-          || record.generationRoot === "") return { removed: [] }; // Malformed hold: unknown holder.
+          || record.generationRoot === "") return POSTPONED; // Malformed hold: unknown holder.
         const resolved = await resolveCandidate(record.generationRoot);
-        if (!resolved.ok) return { removed: [] };
+        if (!resolved.ok) return POSTPONED;
         referenced.add(resolved.root);
       }
     }
@@ -319,6 +323,19 @@ export async function activatePending(root, { prepare = prepareCandidate, env =
   if (outcome.activated) {
     try { await reclaimGenerations({ root, active: activatedRoot, pidIsAlive }); }
     catch { /* Best effort; never fails an activation that already succeeded. */ }
+    // The reclaim above is this, older, code's rule (#208). The activated
+    // generation's own rule runs next, from its own files as its refresh did,
+    // and records that it ran. A target without it (an older release) is left
+    // to its own worker; nothing here can fail the activation.
+    try { await reclaimAsActivated(root, activatedRoot); }
+    catch { /* Best effort, as above. */ }
   }
   return outcome;
 }
+
+async function reclaimAsActivated(root, activatedRoot) {
+  const file = path.join(activatedRoot, "node_modules", "@agents-can-communicate", "cli", "src",
+    "managed-runtime", "worker.mjs");
+  const { reclaimAsActive } = await import(pathToFileURL(file).href);
+  if (typeof reclaimAsActive === "function") await reclaimAsActive(root, activatedRoot);
+}

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,10 @@
-import { activatePending } from "./activation.mjs";
+import { realpath } from "node:fs/promises";
+import path from "node:path";
+
+import { activatePending, reclaimGenerations } from "./activation.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 +65,40 @@ 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 });
+    // A postponed pass is recorded as unfinished, 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,
+      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) {

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.4",
   "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.4",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -0,0 +1,18 @@
+import { listSessionBindings, loadNativeAttempt } from "@agents-can-communicate/adapter-sdk";
+
+/**
+ * Why a session has no live transport, as its own last native attempt said.
+ *
+ * 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 });
+  return attempt !== null && attempt.state !== "active" ? attempt.reasonCode : null;
+}

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

@@ -1,5 +1,6 @@
-import { evaluateVersionContract } from "@agents-can-communicate/adapter-sdk";
+import { NATIVE_REASON_CODES, evaluateVersionContract } 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 +46,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, 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.
+  async function withoutLiveTransport(participantId, target) {
+    const reason = await Promise.resolve()
+      .then(() => readNativeReason({ sessionId: target.sessionId, generation: target.generation }))
+      .catch(() => null);
+    return { ...durable(participantId, "no_live_transport"),
+      ...(NATIVE_REASON_CODES.includes(reason) ? { nativeReasonCode: reason } : {}) };
+  }
+
   // 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 +106,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.4",
   "private": true,
   "type": "module",
   "exports": {