agents-can-communicate 0.7.0 → 0.8.0

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

@@ -1,6 +1,7 @@
 import { classifySessionPresence } from "./sessions.mjs";
 import { computeAttention } from "./attention.mjs";
 import { isCurrentIntent } from "./intents.mjs";
+import { decisionView, isCurrentDecision } from "./decision-state.mjs";
 
 /**
  * Protection level, reported from what is actually enforceable.
@@ -87,6 +88,36 @@ export function createStatusService(ports, sessions, deliveryBindings) {
     const claims = snapshot.claims
       .filter(claim => Date.parse(claim.expiresAt) > Date.parse(now));
     const currentBindings = await deliveryBindings.currentBindings(now);
+    // What each recipient has not fetched yet, and how far it got. Offered is
+    // not read: a transport took the bytes. Queued sits beside it so "0
+    // offered" cannot be mistaken for "nothing waits". Replaced decisions
+    // leave these counts exactly as they leave the inbox.
+    const current = new Set(snapshot.messages.map(decisionView(snapshot.messages))
+      .filter(isCurrentDecision).map(message => message.messageId));
+    const unretrieved = new Map();
+    const tally = key => unretrieved.get(key) ?? { queued: 0, offered: 0 };
+    for (const receipt of snapshot.receipts) {
+      if (!current.has(receipt.messageId)
+        || !["queued", "offered"].includes(receipt.state)) continue;
+      for (const key of [receipt.recipientParticipantId, null]) {
+        const counts = tally(key);
+        unretrieved.set(key, { ...counts, [receipt.state]: counts[receipt.state] + 1 });
+      }
+    }
+
+    // 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,
@@ -98,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,
@@ -114,6 +146,10 @@ export function createStatusService(ports, sessions, deliveryBindings) {
         // a done record made the command and this line contradict each other.
         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
@@ -148,6 +184,7 @@ export function createStatusService(ports, sessions, deliveryBindings) {
         stale: live.filter(item => item.presence === "stale").length,
         claims: claims.length,
         messages: snapshot.messages.length,
+        unretrieved: tally(null),
       },
     };
   }

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

@@ -4,6 +4,7 @@ import { computeAttention } from "./attention.mjs";
 import { classifySessionPresence } from "./sessions.mjs";
 import { assertMessageId, messagePage } from "./message-pages.mjs";
 import { decisionView, isCurrentDecision } from "./decision-state.mjs";
+import { offerFacts } from "./receipts.mjs";
 
 const DEFAULT_LIMIT = 100;
 const CURSOR = /^[0-9]{16}$/;
@@ -38,7 +39,7 @@ export function createSyncService(ports, sessions) {
     }
     if (exact) assertMessageId(input.messageId);
     const snapshot = await store.snapshot(input.workspaceId ?? store.workspaceId,
-      { kinds: ["message"] });
+      { kinds: exact ? ["message", "receipt"] : ["message"] });
     const messages = snapshot.messages.map(decisionView(snapshot.messages));
     if (!exact) return messagePage(messages, input,
       { include: message => input.current !== true || isCurrentDecision(message),
@@ -47,7 +48,15 @@ export function createSyncService(ports, sessions) {
     if (message === undefined) {
       throw new AccError(EXIT.DATA, "message is not in this workspace's history");
     }
-    return { scope: "history", view: "message", items: [message], nextCursor: null };
+    // Beside the message rather than inside it: the router offers `items[0]`
+    // to a transport, and a sender asking "did they get it" wants every
+    // recipient's answer. `sync --scope full` already shows all of it.
+    const receipts = snapshot.receipts
+      .filter(receipt => receipt.messageId === message.messageId)
+      .sort((left, right) => left.recipientParticipantId.localeCompare(right.recipientParticipantId))
+      .map(receipt => ({ recipientParticipantId: receipt.recipientParticipantId,
+        state: receipt.state, updatedAt: receipt.updatedAt, offer: offerFacts(receipt) }));
+    return { scope: "history", view: "message", items: [message], receipts, nextCursor: null };
   }
 
   async function sync(input = {}) {

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/delivery-router",
-  "version": "0.7.0",
+  "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.0",
+  "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

@@ -237,7 +237,7 @@ async function openContext({ event, adapterId, dataHome, runtime, env, deadline
 // `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 }) {
+  render = text => adapter.injectOutcome?.(text), activationHint = null, repeats = true }) {
   const sync = await context.service.sync({ sessionId: binding.accSessionId,
     cursor: null, scope: "delta" });
 
@@ -251,11 +251,22 @@ async function projectTurn({ binding, context, adapter, adapterId,
   // Without this the projector's peer block never runs in production: an
   // agent sees only the obligation attention line, not the durable body that
   // may be offered after the stdout transport succeeds.
+  // Decided before selection: a repeat is taken out of the reminder lists, so
+  // asking for one this turn cannot show is how a message would go quiet.
+  // The ceiling a team agreed on in `acc.workspace.json`, or the default when
+  // there is no config. Validated by the protocol and, until now, never read:
+  // the projector was always called with its own default.
+  const effective = effectiveCapabilities(adapter, binding);
+  const hasStructuredRenderer = typeof adapter.renderContextResult === "function";
+  const canOfferNextTurn = effective.delivery.nextTurn === true && hasStructuredRenderer;
   const delivery = await context.service.nextTurnDelivery({
     workspaceId: context.descriptor.id,
     participantId: mine?.participantId,
-    exceptSessionId: binding.accSessionId });
-  const messages = delivery.queuedMessages;
+    exceptSessionId: binding.accSessionId,
+    repeats: repeats && canOfferNextTurn });
+  // New bodies first, so a repeat is what the byte budget drops.
+  const messages = [...delivery.queuedMessages, ...delivery.repeatMessages];
+  const repeating = new Set(delivery.repeatMessages.map(message => message.messageId));
 
   // Only this hook's payload selected the binding. Supply its own pair as
   // trusted context, outside peer bodies, rather than exporting inheritable
@@ -278,16 +289,11 @@ async function projectTurn({ binding, context, adapter, adapterId,
       hintFits);
   }
 
-  // The ceiling a team agreed on in `acc.workspace.json`, or the default when
-  // there is no config. Validated by the protocol and, until now, never read:
-  // the projector was always called with its own default.
-  const effective = effectiveCapabilities(adapter, binding);
-  const hasStructuredRenderer = typeof adapter.renderContextResult === "function";
-  const canOfferNextTurn = effective.delivery.nextTurn === true && hasStructuredRenderer;
   const projectionInput = { ...sync, messages: canOfferNextTurn ? messages : [],
     liveOfferedMessageIds: delivery.liveOfferedMessageIds,
     reminderMessageIds: delivery.reminderMessageIds,
     roomMessageIds: delivery.roomMessageIds,
+    repeatOffers: delivery.repeatOffers,
     currentParticipantId: mine?.participantId };
   // Credentials alone cannot replace the command that reaches a queued body.
   // If both cannot fit, preserve recovery and explain the missing owner pair.
@@ -346,7 +352,8 @@ async function projectTurn({ binding, context, adapter, adapterId,
       recipientParticipantId: mine.participantId,
       targetSessionId: binding.accSessionId, targetGeneration: binding.generation,
       transport: "next-turn", adapterId,
-      clientVersion: binding.clientVersion }));
+      clientVersion: binding.clientVersion,
+      ...(repeating.has(message.messageId) ? { repeat: true } : {}) }));
   // Same again: Kimi Code shows the model a hook's raw stdout, while Gemini
   // and Claude Code want an envelope and drop a bare string.
   // The entry point owns the transport boundary. This handler only prepares
@@ -499,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.
@@ -583,7 +590,9 @@ const HANDLERS = {
     const current = await context.service.locateSession(binding.accSessionId);
     if (current === null || current.record.state !== "open"
       || current.record.generation !== binding.generation) return {};
-    const turn = await projectTurn({ ...input,
+    // A repeat is a body the model may already have. It rides on the next
+    // turn that happens anyway and never buys a model call of its own.
+    const turn = await projectTurn({ ...input, repeats: false,
       render: text => adapter.continueTurnOutcome({ reason: text, payload }) });
     return (turn.offerInputs ?? []).length === 0 ? {} : turn;
   },

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/installer",
-  "version": "0.7.0",
+  "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";

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

@@ -2,10 +2,7 @@ import { execFile } from "node:child_process";
 import { access, constants } from "node:fs/promises";
 import path from "node:path";
 
-import { defaultBootstrap } from "@agents-can-communicate/adapter-sdk";
-
-import { installShellBootstrap, planShellBootstrap, uninstallShellBootstrap }
-  from "./shell-bootstrap.mjs";
+import { uninstallShellBootstrap } from "./shell-bootstrap.mjs";
 import { LIVE_POLICIES, livePolicyOf } from "./live-policy.mjs";
 
 // The installer's side of a native activation: which owned mechanisms an
@@ -16,26 +13,15 @@ import { LIVE_POLICIES, livePolicyOf } from "./live-policy.mjs";
 // apply, and only when it did not already exist.
 
 export { LIVE_POLICIES, livePolicyOf };
-const MECHANISM_ORDER = ["native-config", "native-service", "shell-bootstrap"];
+const MECHANISM_ORDER = ["native-config", "native-service"];
 const SERVICE_TIMEOUT_MS = 15_000;
 
-export const shellOf = env => {
-  const shell = env?.SHELL;
-  return typeof shell === "string" && shell !== "" ? path.basename(shell) : null;
-};
+// Where ACC 0.7.x put its `claude` shim. An edited shim is kept rather than
+// deleted, so detection still has to look past this directory.
 export const shimDirFor = stateRoot => path.join(stateRoot, "bin");
-// `.zshrc`, deliberately, and that makes the shim interactive-only: zsh reads
-// this file for interactive shells and not for `zsh -lc` or a script. An
-// interactive launch is where a client session comes from, and putting the PATH
-// entry somewhere every shell reads would put ACC in front of a vendor command
-// in scripts and CI that never asked for it. Worth knowing when checking an
-// install: a non-interactive shell resolving the vendor binary directly is this
-// choice working, not a broken bootstrap.
-export const rcFileFor = (home, shell) => (shell === "zsh" && typeof home === "string"
-  ? path.join(home, ".zshrc") : null);
 
-// The vendor executable a shim will exec: the first executable on PATH that is
-// not ACC's own shim directory, so a shim never resolves itself.
+// The vendor executable to probe: the first executable on PATH outside the
+// excluded directories, so a kept 0.7.x shim is never probed as the client.
 export async function resolveExecutable(command, { pathEnv = "", exclude = [] } = {}) {
   const excluded = exclude.filter(Boolean).map(directory => path.resolve(directory));
   for (const directory of String(pathEnv).split(path.delimiter).filter(Boolean)) {
@@ -65,11 +51,7 @@ const renderCommand = command => [command.executable, ...command.args].join(" ")
 export function describeActivation(activation) {
   const lines = [];
   for (const mechanism of ordered(activation.mechanisms)) {
-    if (mechanism.kind === "shell-bootstrap") {
-      lines.push(`create shim ${path.join(activation.shimDir, mechanism.command)} for `
-        + `${mechanism.command} (${activation.livePolicy} live delivery)`);
-      lines.push(`add a PATH block to ${activation.rcFile}`);
-    } else if (mechanism.kind === "native-config") {
+    if (mechanism.kind === "native-config") {
       lines.push(`write native config ${mechanism.artifactIds.join(", ")}`);
     } else if (mechanism.preExisting) {
       lines.push(`use the existing ${mechanism.serviceId} service`);
@@ -96,47 +78,27 @@ export function describeDeactivation(nativeActivation) {
   return lines;
 }
 
-export async function applyNativeActivation({ adapter, activation, dataHome,
-  node = process.execPath, bootstrap = defaultBootstrap(), exec = defaultExec }) {
+export async function applyNativeActivation({ activation, exec = defaultExec }) {
   const record = { livePolicy: activation.livePolicy,
     protocolContract: activation.protocolContract, mechanisms: [] };
-  let shell = null;
-  try {
-    for (const mechanism of ordered(activation.mechanisms)) {
-      if (mechanism.kind === "native-config") {
-        record.mechanisms.push({ kind: mechanism.kind, artifactIds: [...mechanism.artifactIds] });
-      } else if (mechanism.kind === "native-service") {
-        let createdByAcc = false;
-        if (!mechanism.preExisting && mechanism.applyCommand !== null) {
-          await exec(mechanism.applyCommand.executable, mechanism.applyCommand.args);
-          createdByAcc = true;
-        }
-        record.mechanisms.push({ kind: mechanism.kind, serviceId: mechanism.serviceId,
-          createdByAcc, teardownCommand: mechanism.teardownCommand });
-      } else {
-        const plan = planShellBootstrap({ shell: activation.shell, rcFile: activation.rcFile,
-          shimDir: activation.shimDir, runtime: { node, bootstrap, dataHome },
-          entries: [{ adapterId: adapter.id, command: mechanism.command,
-            realExecutable: mechanism.realExecutable, prefixArgs: mechanism.prefixArgs,
-            livePolicy: activation.livePolicy }] });
-        const result = await installShellBootstrap({ plan });
-        if (!result.ok) throw new Error(`shell bootstrap refused: ${result.reasonCode}`);
-        shell = result;
-        record.mechanisms.push({ kind: mechanism.kind, command: mechanism.command, shimDir: activation.shimDir,
-          ownedFiles: result.shims.map(shim => ({ path: shim.path, sha256: shim.sha256 })),
-          rcFile: result.rcFile });
+  for (const mechanism of ordered(activation.mechanisms)) {
+    if (mechanism.kind === "native-config") {
+      record.mechanisms.push({ kind: mechanism.kind, artifactIds: [...mechanism.artifactIds] });
+    } else if (mechanism.kind === "native-service") {
+      let createdByAcc = false;
+      if (!mechanism.preExisting && mechanism.applyCommand !== null) {
+        await exec(mechanism.applyCommand.executable, mechanism.applyCommand.args);
+        createdByAcc = true;
       }
+      record.mechanisms.push({ kind: mechanism.kind, serviceId: mechanism.serviceId,
+        createdByAcc, teardownCommand: mechanism.teardownCommand });
+    } else {
+      // validateNativeActivationPlan refuses a shell bootstrap before any plan
+      // gets here; this is the same refusal for a hand-built one.
+      throw new Error("shell-bootstrap activation was removed");
     }
-    return { nativeActivation: record, appendedRcBlock: shell?.rcFile.appended === true };
-  } catch (error) {
-    // Only bytes this operation wrote are taken back; a pre-existing service
-    // or a user's own file is never touched on the way out.
-    if (shell !== null) {
-      await uninstallShellBootstrap({ ownership: { shims: shell.shims, shimDir: activation.shimDir,
-        rcFile: shell.rcFile } }).catch(() => null);
-    }
-    throw error;
   }
+  return { nativeActivation: record };
 }
 
 // Compare planned mechanisms with the deletion authority saved by older installs.

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

@@ -28,6 +28,8 @@ export async function fingerprint(file) {
   }
 }
 
+const CLIENT_ORPHAN_MARKER = ".orphaned_at";
+
 /**
  * Fingerprint of a whole directory ACC created.
  *
@@ -45,7 +47,11 @@ export async function treeFingerprint(root) {
     if (error.code === "ENOTDIR") return fingerprint(root);
     throw error;
   }
-  const files = entries.filter(entry => entry.isFile())
+  // Claude Code marks a plugin cache version its registry no longer names with
+  // `.orphaned_at`, and removes the marker again if the version comes back. That
+  // is the client's own bookkeeping inside a copy ACC keeps on purpose, never an
+  // edit, and ACC never writes a file by that name.
+  const files = entries.filter(entry => entry.isFile() && entry.name !== CLIENT_ORPHAN_MARKER)
     .map(entry => path.relative(root, path.join(entry.parentPath ?? entry.path, entry.name)))
     .sort();
   const hash = createHash("sha256");