agents-can-communicate 0.7.1 → 0.8.0

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

@@ -7,24 +7,13 @@ import { canonicalManagerRoot, readControl, readManagedJson } from "./state.mjs"
 import { commandPrefix } from "./command-prefix.mjs";
 
 export const ENTRY_KINDS = Object.freeze([
-  "acc", "acc-hook", "acc-mcp", "acc-bootstrap", "acc-claude-channel", "acc-antigravity-relay",
+  "acc", "acc-hook", "acc-mcp", "acc-antigravity-relay",
 ]);
 
-const BOOTSTRAP_FLAGS = new Map([["--adapter", "adapter"], ["--real-executable", "realExecutable"],
-  ["--data-home", "dataHome"]]);
-
-/** Shared with the runtime; parse before admission without importing installer code. */
-export function parseBootstrapOptions(args) {
-  const options = {};
-  for (let index = 0; index < args.length; index += 2) {
-    const key = BOOTSTRAP_FLAGS.get(args[index]);
-    const value = args[index + 1];
-    if (key === undefined || typeof value !== "string" || value === "" || key in options) return null;
-    options[key] = value;
-  }
-  return BOOTSTRAP_FLAGS.values().every(key => key in options) && path.isAbsolute(options.dataHome)
-    ? options : null;
-}
+// Kinds a 0.7.x install wrote a launcher for. The package still ships their
+// entrypoints for 0.7.x updaters and launchers; a current install removes the
+// launchers themselves.
+export const RETIRED_ENTRY_KINDS = Object.freeze(["acc-bootstrap", "acc-claude-channel"]);
 
 // Bootstrap resolution deliberately needs only Node built-ins: no selected
 // generation is imported until admission and its actual PID lease are durable.
@@ -43,11 +32,9 @@ export function invokedDirectly(url) {
 
 function unavailable(kind) {
   // Never reflect control file content or payloads into a client diagnostic.
-  if (kind === "acc-hook" || kind === "acc-claude-channel" || kind === "acc-antigravity-relay") {
+  if (kind === "acc-hook" || kind === "acc-antigravity-relay") {
     process.stderr.write("acc: coordination unavailable during runtime update; session may continue\n");
     process.exitCode = 0;
-  } else if (kind === "acc-bootstrap") {
-    process.exitCode = 1; // The vendor shell shim launches its original command.
   } else {
     process.stderr.write("acc: runtime unavailable; retry after the update or run acc update to recover\n");
     process.exitCode = 4;
@@ -83,28 +70,12 @@ async function updateImplementation(packageRoot, control) {
 export async function runEntry({ kind, packageRoot, managerRoot, managedRequired = false }) {
   if (!ENTRY_KINDS.includes(kind)) throw new Error("unknown ACC entry point");
   const command = kind === "acc" ? commandPrefix(process.argv.slice(2)).command : null;
-  const bootstrapOptions = kind === "acc-bootstrap" ? parseBootstrapOptions(process.argv.slice(2)) : null;
-  if (kind === "acc-bootstrap" && bootstrapOptions === null) {
-    if (process.env.ACC_BOOTSTRAP_DEBUG === "1") {
-      process.stderr.write("acc-bootstrap: usage: --adapter <id> --real-executable <path> --data-home <path>\n");
-    }
-    process.exitCode = 2;
-    return;
-  }
   let selected = packageRoot;
   let managed = null;
   let managementOnly = false;
   let root;
   try {
-    const requestedDataHome = bootstrapOptions === null ? null : await canonicalManagerRoot(bootstrapOptions.dataHome);
-    const requestedRoot = requestedDataHome === null ? null
-      : await canonicalManagerRoot(path.join(requestedDataHome, "acc", "runtime"));
-    if (managerRoot && requestedDataHome !== null
-      && requestedDataHome !== await canonicalManagerRoot(path.dirname(path.dirname(managerRoot)))) {
-      throw new Error("bootstrap cache home differs from its launcher");
-    }
-    root = await canonicalManagerRoot(managerRoot ?? requestedRoot ?? managerLocation());
-    if (requestedRoot !== null && root !== requestedRoot) throw new Error("bootstrap data home differs from its launcher");
+    root = await canonicalManagerRoot(managerRoot ?? managerLocation());
     const control = await readControl(root);
     if (control !== null) {
       selected = control.active.root;
@@ -138,13 +109,6 @@ export async function runEntry({ kind, packageRoot, managerRoot, managedRequired
       } catch { /* Fall through to the same graceful unavailability below. */ }
     }
     unavailable(kind);
-    if (kind === "acc-claude-channel" && selected) {
-      try {
-        const { startInertChannel } = await import(pathToFileURL(path.join(selected,
-          "bin", "entrypoints", "claude-channel-stdio.mjs")).href);
-        startInertChannel();
-      } catch { /* The stderr notice above already fired either way. */ }
-    }
     return;
   }
   const runtime = await import(pathToFileURL(path.join(selected, "bin", "entrypoints", `${kind}.mjs`)).href);

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

@@ -1,7 +1,7 @@
 import { createHash, randomUUID } from "node:crypto";
 import { lstat, mkdtemp, open, readFile, rename, rm } from "node:fs/promises";
 import path from "node:path";
-import { ENTRY_KINDS } from "./entry.mjs";
+import { ENTRY_KINDS, RETIRED_ENTRY_KINDS } from "./entry.mjs";
 import { managedDirectory, syncDirectory } from "./state.mjs";
 
 const MODULES = ["entry.mjs", "command-prefix.mjs", "state.mjs", "generation-files.mjs",
@@ -14,8 +14,6 @@ async function durableFile(file, bytes, mode = 0o600) {
 
 export const stablePaths = root => ({
   cli: path.join(root, "bin", "acc.mjs"), runner: path.join(root, "bin", "acc-hook.mjs"),
-  bootstrap: path.join(root, "bin", "acc-bootstrap.mjs"),
-  channel: path.join(root, "bin", "acc-claude-channel.mjs"),
   antigravityRelay: path.join(root, "bin", "acc-antigravity-relay.mjs"),
 });
 
@@ -57,6 +55,10 @@ export async function writeLaunchers(root, packageRoot) {
       await rename(temporary, path.join(bin, `${kind}.mjs`));
     } finally { await rm(temporary, { force: true }); }
   }
+  // A 0.7.x `claude` shim or plugin copy that still reaches for one of these
+  // finds nothing: the shim then launches the vendor command untouched, and a
+  // re-laid plugin names none of them.
+  for (const kind of RETIRED_ENTRY_KINDS) await rm(path.join(bin, `${kind}.mjs`), { force: true });
   await syncDirectory(bin);
   return stablePaths(root);
 }

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

@@ -1,5 +1,5 @@
 import path from "node:path";
-import { applyPlan, detectInstallation, livePolicyOf, loadOwnership, planInstallation, shellOf }
+import { applyPlan, detectInstallation, livePolicyOf, loadOwnership, planInstallation }
   from "@agents-can-communicate/installer";
 import { ALL_ADAPTERS, clientContext, probeTimeout } from "../install-command.mjs";
 import { stablePaths, writeLaunchers } from "./launchers.mjs";
@@ -17,7 +17,7 @@ export async function prepareRefresh({ control, root, env = process.env, callerP
   // session open across the update keeps running from the outgoing copy until it
   // restarts. Naming it here keeps that copy; everything older than it goes.
   const context = { ...clientContext(control.home, path.join(dataHome, "acc"),
-    { env, shell: shellOf(env), dataHome }), ...stablePaths(root),
+    { env, dataHome }), ...stablePaths(root),
   keepPreviousVersion: control.active.version };
   const recorded = (await loadOwnership({ dataHome })).installs;
   const detected = await detectInstallation({ adapters, context, probeTimeoutMs: probeTimeout(env) });
@@ -38,8 +38,7 @@ export async function prepareRefresh({ control, root, env = process.env, callerP
   }
   return async () => {
     await writeLaunchers(root, control.pending.root);
-    const result = await applyPlan({ plan, adapters, context, dataHome, accVersion: control.pending.version,
-      activation: { bootstrap: context.bootstrap } });
+    const result = await applyPlan({ plan, adapters, context, dataHome, accVersion: control.pending.version });
     return { ...result, failed: result.failed.map(failure => ({ ...failure,
       paths: plan.operations.find(operation => operation.adapterId === failure.adapterId)
         ?.artifacts?.map(artifact => artifact.path).filter(file => typeof file === "string") ?? [],

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

@@ -34,11 +34,11 @@ export function nativeRemediation(entry) {
       + "  # opt in to automatic peer requests; may spend tokens");
   } else if (native.configured && native.activation === "missing") {
     steps.push(`acc install --adapter ${entry.adapterId}`
-      + "  # complete the missing native launch setup from a supported shell");
+      + "  # complete the missing native delivery setup");
   } else if (native.configured && native.runtime !== "active"
     && !["needed", "blocked", "unsupported"].includes(service?.state)) {
     steps.push(`${entry.displayName}: no verified live channel in this workspace; `
-      + "open a new terminal, start a new client session and check its integration/channel prompts; "
+      + "start a new client session and check its integration prompts; "
       + "then run acc doctor here");
   }
   if (native.reasonCode === "native_endpoint_unavailable") {

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

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

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

@@ -33,6 +33,9 @@ const ageBand = (session, age) =>
  * @returns {"online" | "stale" | "offline"}
  * @throws {AccError} EXIT.USAGE when pidIsAlive is not a function.
  */
+// A client's end reason is a short word of its own ("clear", "logout").
+const END_REASON = /^[a-z][a-z0-9_-]{0,63}$/;
+
 export function classifySessionPresence(session, now, pidIsAlive) {
   // Required rather than defaulted. A probe that defaults to "everyone is
   // alive" turns a forgotten call site into a check that silently passes, which
@@ -149,10 +152,14 @@ export function createSessionService(ports) {
     }, { kinds: ["session"] });
   }
 
-  async function closeSession({ sessionId, workspaceId, generation }) {
+  async function closeSession({ sessionId, workspaceId, generation, endReason = null }) {
+    // The client's own word for why, kept in extensions: an older ACC reading
+    // the same store skips them, and the session.closed event is unchanged.
+    const reason = typeof endReason === "string" && END_REASON.test(endReason) ? endReason : null;
     const close = current => {
       assertGeneration({ record: current }, generation, "close", workspaceId ?? store.workspaceId);
-      return { ...current, state: "closed", heartbeatAt: clock.now() };
+      return { ...current, state: "closed", heartbeatAt: clock.now(),
+        ...(reason === null ? {} : { extensions: { ...(current.extensions ?? {}), endReason: reason } }) };
     };
     let ephemeral = null;
     await store.ephemeral.delete("session", sessionId, async current => {
@@ -179,6 +186,21 @@ export function createSessionService(ports) {
     }, { kinds: ["session"] });
   }
 
+  /** The participant's most recent session, open or closed, or null. */
+  async function lastSessionOf({ participantId, workspaceId }) {
+    const resolved = workspaceId ?? store.workspaceId;
+    const snapshot = resolved === undefined ? null
+      : await store.snapshot(resolved, { kinds: ["workspace", "session"] });
+    const records = snapshot?.workspace === null
+      ? await store.ephemeral.list("session")
+      : snapshot?.sessions ?? await store.ephemeral.list("session");
+    const [last] = records.filter(session => session.participantId === participantId)
+      .sort((left, right) => Date.parse(right.heartbeatAt) - Date.parse(left.heartbeatAt)
+        || right.sessionId.localeCompare(left.sessionId));
+    return last === undefined ? null : { sessionId: last.sessionId, generation: last.generation,
+      state: last.state, endReason: last.extensions?.endReason ?? null };
+  }
+
   async function listLiveSessions({ participantId, workspaceId, now = clock.now() }) {
     const resolved = workspaceId ?? store.workspaceId;
     const snapshot = resolved === undefined ? null
@@ -198,6 +220,7 @@ export function createSessionService(ports) {
     resumeSession,
     heartbeatSession,
     closeSession,
+    lastSessionOf,
     listLiveSessions,
     locateSession: locate,
     ensureMaterialised: options => ensureMaterialised(ports, options),

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

@@ -105,6 +105,20 @@ export function createStatusService(ports, sessions, deliveryBindings) {
       }
     }
 
+    // A participant with no live session but messages waiting for it stays in
+    // the roster, by its latest session, so a sender can see where they went.
+    const liveParticipants = new Set(live.map(item => item.session.participantId));
+    const latest = new Map();
+    for (const { session } of classified) {
+      const seen = latest.get(session.participantId);
+      if (seen === undefined || Date.parse(session.heartbeatAt) > Date.parse(seen.heartbeatAt)) {
+        latest.set(session.participantId, session);
+      }
+    }
+    const awaited = new Set([...latest.values()].filter(session => !liveParticipants.has(session.participantId)
+      && (tally(session.participantId).queued + tally(session.participantId).offered) > 0)
+      .map(session => session.sessionId));
+
     return {
       workspaceId,
       materialised: durable,
@@ -115,7 +129,8 @@ export function createStatusService(ports, sessions, deliveryBindings) {
       // after a month of work this listed sixty entries for one live session.
       // `acc status --all` is how the worktree-cleanup question is asked.
       participants: classified
-        .filter(item => input.all === true || item.presence !== "offline")
+        .filter(item => input.all === true || item.presence !== "offline"
+          || awaited.has(item.session.sessionId))
         .map(({ session, presence }) => ({
         sessionId: session.sessionId,
         participantId: session.participantId,
@@ -132,6 +147,9 @@ export function createStatusService(ports, sessions, deliveryBindings) {
         intent: intents.find(intent => intent.sessionId === session.sessionId
           && isCurrentIntent(intent))?.summary ?? null,
         unretrieved: tally(session.participantId),
+        // The client's reason when it ended the session, such as Claude Code's
+        // "clear". Kept in the record's extensions, so it is null for 0.7.x.
+        ...(presence === "offline" ? { endReason: session.extensions?.endReason ?? null } : {}),
       })),
       // The owner is named twice on purpose. Every command that reaches a peer
       // takes a participant id, so a claim that gave only a session id sent the

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

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

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

@@ -5,7 +5,7 @@ import { refreshExpiredBinding } from "./refresh-binding.mjs";
 const SAFE_ERRORS = new Set(["ambiguous_recipient_sessions", "delivery_disabled",
   "recipient_busy", "recipient_unavailable", "transport_error", "transport_rejected", "transport_permission_denied",
   "unsupported_client_version"]);
-const NAMED_LIVE_TRANSPORTS = new Set(["claude-channel", "codex-app-server"]);
+const NAMED_LIVE_TRANSPORTS = new Set(["claude-inbox", "codex-app-server"]);
 
 const adaptersById = adapters => adapters instanceof Map
   ? adapters
@@ -72,10 +72,9 @@ export function createDeliveryRouter({ service, adapters, clock, platform = HOST
   readLivePolicy }) {
   const registry = adaptersById(adapters);
 
+  // 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) {
-    if (adapter?.nativeDelivery?.policySource !== "installation-record") {
-      return LIVE_POLICIES.has(binding.livePolicy) ? binding.livePolicy : "off";
-    }
     if (typeof readLivePolicy !== "function") return "off";
     try {
       const policy = await readLivePolicy({ adapter, binding });
@@ -101,7 +100,14 @@ export function createDeliveryRouter({ service, adapters, clock, platform = HOST
     // endpoint lease never sends a hook heartbeat: a daemon is reachability,
     // not evidence that this particular session thread is still present.
     const liveSessions = await service.listLiveSessions({ participantId, now });
-    if (liveSessions.length === 0) return durable(participantId, "recipient_unavailable");
+    if (liveSessions.length === 0) {
+      // No open session: the message waits until one starts or resumes. The
+      // client's own reason, when it gave one (Claude Code's /clear), is passed on.
+      const last = typeof service.lastSessionOf === "function"
+        ? await service.lastSessionOf({ participantId }).catch(() => null) : null;
+      return { ...durable(participantId, "recipient_offline"),
+        ...(last?.state === "closed" && typeof last.endReason === "string" ? { endReason: last.endReason } : {}) };
+    }
     if (liveSessions.length > 1) {
       return durable(participantId, "ambiguous_recipient_sessions");
     }
@@ -110,7 +116,9 @@ export function createDeliveryRouter({ service, adapters, clock, platform = HOST
       participantId, now, includeExpired: true }))
       .filter(binding => binding.sessionId === target.sessionId
         && binding.generation === target.generation);
-    if (bindings.length === 0) return durable(participantId, "recipient_unavailable");
+    // 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");
     const evaluated = await Promise.all(bindings.map(async binding => {
       const adapter = registry.get(binding.adapterId);
       return { binding, adapter, policy: await policyFor(adapter, binding) };
@@ -118,7 +126,7 @@ export function createDeliveryRouter({ service, adapters, clock, platform = HOST
     const permitted = evaluated.filter(({ policy }) => permits(policy, message.kind));
     if (permitted.length === 0) return durable(participantId, "delivery_disabled");
     const reachable = permitted.filter(({ binding }) => binding.availableModes.includes("livePush"));
-    if (reachable.length === 0) return durable(participantId, "recipient_unavailable");
+    if (reachable.length === 0) return durable(participantId, "no_live_transport");
     const capable = reachable.filter(({ binding, adapter }) => liveCapable(adapter, binding));
     if (capable.length === 0) {
       return durable(participantId, "unsupported_client_version");
@@ -214,6 +222,15 @@ export function createDeliveryRouter({ service, adapters, clock, platform = HOST
         "unsupported_client_version");
       return durable(participantId, "unsupported_client_version");
     }
+    // A wake put a notice in front of the client, not the body. Recording it
+    // as offered would make the next-turn projection treat the body as already
+    // shown and leave it out of the very turn the wake started. The receipt
+    // stays queued; the hook records the offer once its stdout carried the body.
+    if (adapter.nativeDelivery?.offerKind === "wake") {
+      // The client took the wake but holds it for its user's approval.
+      return { recipientParticipantId: participantId, outcome: "woken", transport,
+        ...(response.pendingApproval === true ? { pendingApproval: true } : {}) };
+    }
     try {
       await service.recordOfferSucceeded({ messageId: message.messageId,
         recipientParticipantId: participantId, targetSessionId: binding.sessionId,

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

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

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

@@ -1,7 +1,7 @@
 import { storeNativeAttempt } from "@agents-can-communicate/adapter-sdk";
 import { readInstalledLivePolicyState } from "@agents-can-communicate/installer";
 
-import { establishNativeBinding, LIVE_POLICIES, livePolicyFrom } from "./native-binding.mjs";
+import { establishNativeBinding } from "./native-binding.mjs";
 
 // A cold worker plus the write has to finish inside this window. 250 ms was
 // not enough on a busy CI runner, so the attempt file never appeared and
@@ -27,13 +27,11 @@ export async function bindNative({ adapter, event, hookBinding, clientVersion, p
     if (Date.now() >= deadline) throw new Error("hook deadline expired");
   };
   assertBudget();
-  const policySource = adapter?.nativeDelivery?.policySource === "installation-record"
-    ? "installation-record" : "bootstrap-environment";
-  const raw = context.env?.ACC_NATIVE_DELIVERY_POLICY;
-  const { policy, policyStatus } = policySource === "installation-record"
-    ? await readInstalledLivePolicyState({ dataHome: context.dataHome, adapterId: adapter.id })
-    : { policy: livePolicyFrom(context.env), policyStatus: raw === undefined ? "missing"
-      : !LIVE_POLICIES.includes(raw) ? "invalid" : raw === "off" ? "off" : "enabled" };
+  // The install record is the only consent a hook reads; see
+  // validateNativeDeliveryContract for the environment source this replaced.
+  const policySource = "installation-record";
+  const { policy, policyStatus } = await readInstalledLivePolicyState({ dataHome: context.dataHome,
+    adapterId: adapter.id });
   assertBudget();
   const result = await establishNativeBinding({ adapter, event, hookBinding, clientVersion, platform,
     livePolicy: policy, service: context.service, runtimeDir: paths.root,

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

@@ -20,15 +20,21 @@ const STATIC_REASONS = new Set(["native_delivery_unsupported", "platform_not_cap
   "version_unavailable", "prerelease_not_captured", "below_minimum_version",
   "known_bad_version"]);
 
-// Only the value a successful owned shell bootstrap exported counts; anything
-// else - missing, blank, differently cased, a number - is off.
-export function livePolicyFrom(env) {
-  const value = env?.ACC_NATIVE_DELIVERY_POLICY;
-  return LIVE_POLICIES.includes(value) ? value : "off";
-}
-
 const isPid = value => Number.isInteger(value) && value > 0;
 
+// An adapter may write its private endpoint before the static rule below judges
+// the handshake, or after this hook stopped waiting. Nothing publishes such an
+// endpoint, so nothing would ever retire it, and a refused client binds again
+// on every turn. Fail-open and never awaited past the adapter's own answer.
+function discardEndpoint(adapter, handshake, runtimeDir) {
+  const opaqueEndpointRef = handshake?.opaqueEndpointRef;
+  if (typeof opaqueEndpointRef !== "string" || opaqueEndpointRef === ""
+    || typeof adapter?.retireNativeSession !== "function") return Promise.resolve();
+  return Promise.resolve().then(() => adapter.retireNativeSession({
+    binding: { opaqueEndpointRef, clientVersion: handshake.clientVersion ?? null }, runtimeDir }))
+    .catch(() => {});
+}
+
 export async function establishNativeBinding({ adapter, event, hookBinding, clientVersion,
   platform, livePolicy, service, runtimeDir, clock, env,
   timeoutMs = DEFAULT_TIMEOUT_MS, heartbeatCadenceMs = DEFAULT_CADENCE_MS }) {
@@ -57,16 +63,23 @@ export async function establishNativeBinding({ adapter, event, hookBinding, clie
   let timer = null;
   try {
     const budget = Math.max(1, Math.floor(timeoutMs));
+    const pending = Promise.resolve().then(() => adapter.bindNativeSession({ event, clientPid,
+      clientVersion, runtimeDir, timeoutMs: budget, env }));
+    // An answer that lands after the budget has nobody left to use it.
+    let timedOut = false;
+    pending.then(late => { if (timedOut) discardEndpoint(adapter, late, runtimeDir); }, () => {});
     const handshake = await Promise.race([
-      adapter.bindNativeSession({ event, clientPid, clientVersion, runtimeDir,
-        timeoutMs: budget, env }),
+      pending,
       new Promise((_resolve, reject) => {
-        timer = setTimeout(() => reject(Object.assign(new Error("native handshake timed out"),
-          { code: "ETIMEDOUT" })), budget);
+        timer = setTimeout(() => {
+          timedOut = true;
+          reject(Object.assign(new Error("native handshake timed out"), { code: "ETIMEDOUT" }));
+        }, budget);
       }),
     ]);
     const verdict = validateNativeHandshake(adapter, { clientVersion, platform, handshake });
     if (!verdict.ok) {
+      await discardEndpoint(adapter, handshake, runtimeDir);
       return outcome(STATIC_REASONS.has(verdict.reasonCode) ? "unsupported" : "degraded",
         verdict.reasonCode);
     }

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

@@ -506,7 +506,7 @@ const HANDLERS = {
     const owner = { sessionId: binding.accSessionId, generation: binding.generation };
     const current = await context.service.locateSession(binding.accSessionId);
     if (current?.record.generation === binding.generation && current.record.state === "open") {
-      await context.service.closeSession(owner);
+      await context.service.closeSession({ ...owner, endReason: event.endReason ?? null });
     } else {
       // Close may have committed before this hook died. Retire only the old
       // endpoint and binding; do not close a replacement or repeat a close event.

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

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

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

@@ -1,3 +1,6 @@
+import { readdir, rm } from "node:fs/promises";
+import path from "node:path";
+
 import { applyServiceSetup } from "./service-setup.mjs";
 import { applyNativeActivation, deactivateNative } from "./native-activation.mjs";
 import { finalizeRemoval, missingArtifactParents, recordInstall,
@@ -52,12 +55,10 @@ export async function applyPlan({ plan, adapters, context, dataHome, dryRun = fa
           retainedMechanisms = report.retainedMechanisms;
         }
         let native = operation.retainedNativeActivation ?? null;
-        let appendedRcBlock = false;
         if (operation.nativeActivation !== undefined) {
-          const applied = await applyNativeActivation({ adapter,
-            activation: operation.nativeActivation, dataHome, ...activation });
+          const applied = await applyNativeActivation({
+            activation: operation.nativeActivation, ...activation });
           native = applied.nativeActivation;
-          appendedRcBlock = applied.appendedRcBlock;
         }
         if (retainedMechanisms.length > 0) {
           native = { ...(native ?? operation.deactivation),
@@ -71,7 +72,7 @@ export async function applyPlan({ plan, adapters, context, dataHome, dryRun = fa
           artifacts: operation.artifacts, createdDirectories,
           deliveryPolicy: operation.livePolicy, deliveryDecision: operation.deliveryDecision,
           nativeActivation: native });
-        results.operations.push({ ...operation, applied: true, appendedRcBlock,
+        results.operations.push({ ...operation, applied: true,
           needsAction: outcome.needsAction ?? [],
           changes: outcome.changes ?? [], diagnostics: [
             ...(operation.deliveryDiagnostic === undefined
@@ -118,6 +119,19 @@ export async function applyPlan({ plan, adapters, context, dataHome, dryRun = fa
       results.failed.push({ adapterId: operation.adapterId, error: error.message });
     }
   }
+  // The eligibility cache a 0.7.x `claude` shim read before every launch. No
+  // shim reads it any more, and it holds nothing a user wrote.
+  if (!dryRun && typeof dataHome === "string") {
+    await rm(path.join(dataHome, "acc", "native-bootstrap"), { recursive: true, force: true })
+      .catch(() => {});
+    // A 0.7.x Claude Channel unlinked its own registration on a clean exit;
+    // one that crashed left it in its workspace, naming a dead socket.
+    const workspaces = path.join(dataHome, "acc", "workspaces");
+    for (const workspace of await readdir(workspaces).catch(() => [])) {
+      await rm(path.join(workspaces, workspace, "native", "claude"), { recursive: true, force: true })
+        .catch(() => {});
+    }
+  }
   return results;
 }
 

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

@@ -5,7 +5,7 @@ import { capabilityEvidence, effectiveCapabilities, evaluateNativeEligibility,
   validateNativeActivationPlan }
   from "@agents-can-communicate/adapter-sdk";
 
-import { resolveExecutable, shellOf, shimDirFor } from "./native-activation.mjs";
+import { resolveExecutable, shimDirFor } from "./native-activation.mjs";
 
 import { describeDeliveryFallback, describeNativeReason } from "./delivery-diagnostics.mjs";
 
@@ -83,8 +83,7 @@ async function detectNative(adapter, entry, { context, platform, probeTimeoutMs,
     if (facts.eligibility.eligible !== true) {
       const reasonCode = facts.eligibility.reasonCode ?? "feature_probe_failed";
       // A stored policy can be consented to before a service/session exists.
-      // No activation is planned until the full probe passes; bootstrap-based
-      // clients still need their verified plan to disclose launch changes.
+      // No activation is planned until the full probe passes.
       const consentAvailable = adapter.nativeDelivery.policySource === "installation-record"
         && ["native_endpoint_unavailable", "native_session_unavailable"].includes(reasonCode);
       return STATIC_REASONS.has(reasonCode)
@@ -100,10 +99,6 @@ async function detectNative(adapter, entry, { context, platform, probeTimeoutMs,
       return degraded("feature_probe_failed", facts);
     }
     if (!activationPlan.eligible) return degraded(activationPlan.reasonCode, facts);
-    const shell = context?.shell ?? null;
-    if (activationPlan.mechanisms.some(item => item.kind === "shell-bootstrap") && shell !== "zsh") {
-      return { ...degraded("unsupported_shell", facts), activationPlan };
-    }
     return { state: "eligible", reasonCode: null, ...facts, activationPlan };
   } catch {
     return degraded("feature_probe_failed", { realExecutable: null, probe: null, eligibility: null });
@@ -165,6 +160,7 @@ export async function detectInstallation({ adapters, context, probe = spawnProbe
         // on the machine down with it.
         if (detected.blocked) entry.blocked = detected.blocked;
         if (detected.outgoingDelivery) entry.outgoingDelivery = detected.outgoingDelivery;
+        if (detected.inboundDelivery) entry.inboundDelivery = detected.inboundDelivery;
         if (detected.nativeSetup) entry.nativeSetup = detected.nativeSetup;
         entry.diagnostics = [...(detected.diagnostics ?? [])];
         // What a person has to do, as opposed to what is true. Adapters that

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

@@ -5,13 +5,10 @@ export { applyPlan } from "./apply.mjs";
 export { finalizeRemoval, fingerprint, loadOwnership, missingArtifactParents, recordInstall,
   removeEmptyOwnedDirectories, removeOwned, removeOwnedArtifacts, treeFingerprint, verifyOwned }
   from "./ownership.mjs";
-export { BOOTSTRAP_CACHE_SCHEMA, FAILED_TTL_MS, SUPPORTED_TTL_MS, cachePathFor,
-  checkNativeBootstrap } from "./bootstrap-runtime.mjs";
-export { BLOCK_BEGIN, BLOCK_END, SHIM_MARKER, SHIM_POLICIES, SUPPORTED_SHELLS,
-  installShellBootstrap, locateBlock, planShellBootstrap, renderCommandShim, renderPathBlock,
-  shellLiteral, uninstallShellBootstrap, validateShimEntry } from "./shell-bootstrap.mjs";
-export { LIVE_POLICIES, describeActivation, describeDeactivation, livePolicyOf, rcFileFor,
-  resolveExecutable, shellOf, shimDirFor } from "./native-activation.mjs";
+export { BLOCK_BEGIN, BLOCK_END, SHIM_MARKER, locateBlock, uninstallShellBootstrap }
+  from "./shell-bootstrap.mjs";
+export { LIVE_POLICIES, describeActivation, describeDeactivation, livePolicyOf,
+  resolveExecutable, shimDirFor } from "./native-activation.mjs";
 export { readInstalledLivePolicy, readInstalledLivePolicyState } from "./live-policy.mjs";
 export { describeDeliveryFallback, describeInstallDelivery, describeNativeReason }
   from "./delivery-diagnostics.mjs";