agents-can-communicate 0.5.2 → 0.5.4

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

@@ -6,12 +6,12 @@ import { describeDeliveryFallback, detectInstallation, livePolicyOf, loadOwnersh
   from "@agents-can-communicate/installer";
 import { AccError, EXIT } from "@agents-can-communicate/protocol";
 
-import { describeNative, nativeRemediation, nativeState, updateNativeRuntime } from "./native-delivery-status.mjs";
+import { describeDeliveryDecision, describeNative, nativeRemediation, nativeState,
+  updateNativeRuntime } from "./native-delivery-status.mjs";
 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 } from "./main.mjs";
 import { platformPaths } from "./platform-paths.mjs";
 import { noticeUpdate } from "./update-check.mjs";
@@ -173,7 +173,9 @@ export async function diagnoseAdapters({ options, runtime, detect = detectInstal
     // is the acc that copied the skills and manifests into it. They diverge after
     // an npm upgrade with no `acc install`, and reporting both is what makes the
     // divergence legible rather than hidden behind a single reassuring number.
-    return { ...entry, stale, wired, bundleVersion, owned: { modified: owned.modified,
+    return { ...entry, stale, wired, bundleVersion,
+      deliveryDecision: installed === undefined ? null : decisionOf(installed),
+      owned: { modified: owned.modified,
       missing: owned.missing, intact: owned.intact.length },
       nativeDelivery: nativeState(entry.nativeDelivery, livePolicyOf(installed), {
         contract: adapters.find(adapter => adapter.id === entry.adapterId)?.nativeDelivery,
@@ -241,6 +243,7 @@ export async function runDoctor({ options, context, runtime }) {
     registry: ALL_ADAPTERS() });
   for (const adapter of adapters) {
     adapter.remediation.push(...nativeRemediation(adapter));
+    adapter.remediation = [...new Set(adapter.remediation)];
   }
 
   const data = {
@@ -276,9 +279,11 @@ export async function runDoctor({ options, context, runtime }) {
   ...adapters.filter(adapter => adapter.present)
     .map(adapter => `  ${adapter.displayName} live delivery: `
       + `${describeNative(adapter.nativeDelivery, { clientVersion: adapter.version })}; `
+      + `${adapter.nativeDelivery.policy === "off" && adapter.deliveryDecision !== null
+        ? `decision: ${describeDeliveryDecision(adapter.deliveryDecision)}; ` : ""}`
       + `fallback: ${describeDeliveryFallback(adapter)}`),
   ...nativeSessionLines(adapters),
-  ...adapters.filter(adapter => adapter.present && adapter.outgoingDelivery)
+  ...adapters.filter(adapter => adapter.present && adapter.outgoingDelivery?.state === "configured")
     .map(adapter => `  ${adapter.displayName} ${adapter.outgoingDelivery.diagnostic}`),
   ...(manager === null ? [] : [`  automatic updates ${manager.auto ? "on" : "off"}; ACC ${manager.active.version}`
     + (manager.pin ? `; pinned to ${manager.pin}` : ""), ...(update.notice ? [`  ${update.notice}`] : [])]),

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

@@ -34,7 +34,7 @@ const SUMMARY = Object.freeze({
   work: "publish what this session is doing, or --clear when it has stopped",
   claim: "reserve a resource; exit 5 when someone else already holds it",
   release: "give a claim back",
-  ack: "answer a message that asked for one, so it stops asking",
+  ack: "acknowledge receipt without accepting work or writing an answer",
   message: "send a typed message to named participants",
   inbox: "list pending message headers; --message reads one complete message",
   reply: "reply to one message and acknowledge it in the same operation",
@@ -76,6 +76,9 @@ const CHOICES = Object.freeze({
 });
 
 const NOTES = Object.freeze({
+  install: ["Without --delivery, one default-No question covers all selected clients that need a decision.",
+    "--delivery actionable|all gives explicit complete-setup consent; --delivery off disables incoming automatic requests.",
+    "A dry run does not prompt, write configuration, or start a service. Service readiness does not establish a session binding."],
   attach: ["Native hooks already manage their own session. Attach only for a manual CLI session.",
     "Keep the returned session and generation together for subsequent calls.",
     "--cadence is a positive interval in milliseconds."],
@@ -98,8 +101,12 @@ const NOTES = Object.freeze({
     "With history, --type filters before paging; --cursor takes the complete message ID in nextCursor.",
     "history --type decision --current lists terminal decisions and withdrawals, including conflicts. Current means no recorded successor, not consensus.",
     "history --message reads one complete historical message without changing receipts; do not combine with cursor, limit, or type."],
-  reply: ["Returns the outgoing message/delivery plus the original acknowledged receipt."],
-  finish: ["Default status: partial. Records a handoff, releases claims, and closes this ACC session."],
+  ack: ["An unanswered question/request requires reply; ack refuses without changing its receipt.",
+    "Acknowledgement does not prevent a later reply."],
+  reply: ["Returns the outgoing message/delivery plus the original acknowledged receipt.",
+    "May follow ack or an earlier answer. Reuse a client-message-id only for the same send retry."],
+  finish: ["Default status: partial. Records a handoff, releases claims, and closes this ACC session.",
+    "Status describes the original goal; neither partial nor an acknowledged receipt means the peer accepted work."],
   config: ["init writes optional workspace configuration; validate only checks it.",
     "Use acc config <subcommand> --help for its options."],
   update: ["Run acc update to install the latest release and refresh client integrations.",

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

@@ -6,13 +6,16 @@ import { createCodexAdapter } from "@agents-can-communicate/adapter-codex";
 import { createGeminiCliAdapter } from "@agents-can-communicate/adapter-gemini-cli";
 import { createGrokAdapter } from "@agents-can-communicate/adapter-grok";
 import { createKimiAdapter } from "@agents-can-communicate/adapter-kimi";
-import { LIVE_POLICIES, applyPlan, detectInstallation, livePolicyOf,
+import { applyPlan, detectInstallation,
   loadOwnership, planInstallation, rcFileFor, shellOf, shimDirFor }
   from "@agents-can-communicate/installer";
 import { AccError, EXIT } from "@agents-can-communicate/protocol";
 
 import { platformPaths } from "./platform-paths.mjs";
 import { installManaged, uninstallManaged } from "./managed-runtime/install.mjs";
+import { decideDelivery } from "./install-delivery-consent.mjs";
+
+export { decideDelivery } from "./install-delivery-consent.mjs";
 
 // Kept cohesive above 300 lines because this is the install command boundary:
 // detection, consent, planning, application, and reporting share one context
@@ -180,10 +183,11 @@ export function describeOutcome({ action, acted, failed = [], skipped = [],
  * what a malformed `~/.claude/settings.json` produced: the adapter refused,
  * correctly, and the script that ran the installer was told it had worked.
  */
-export function failureOf({ action, acted, failed = [] }) {
+export function failureOf({ action, acted, failed = [], operations = [], skipped = [], home }) {
   if (failed.length === 0) return null;
   return new AccError(EXIT.DATA,
-    describeOutcome({ action, acted, failed }), { failed });
+    [describeOutcome({ action, acted, failed, operations, skipped, home }),
+      ...reloadAdvice(operations)].join("\n"), { failed });
 }
 
 /**
@@ -202,70 +206,6 @@ export function actedOn(result) {
         + (operation.changes?.length ?? 0) > 0)).length;
 }
 
-const isInteractive = runtime => typeof runtime.isInteractive === "function"
-  && runtime.isInteractive() === true;
-
-// One default-No question per supported client. Disclose token use and any
-// repeated channel prompt; declining only promises a verified fallback.
-function questionFor(entry) {
-  const bootstrap = entry.nativeDelivery.activationPlan?.mechanisms
-    .find(mechanism => mechanism.kind === "shell-bootstrap") ?? null;
-  const warns = (bootstrap?.prefixArgs ?? []).some(argument => argument.startsWith("--"));
-  return [
-    `Let ${entry.displayName} answer peer requests while idle? (experimental)`,
-    "  Yes: automatic turns can spend tokens without waiting for you.",
-    ...(entry.outgoingDelivery?.setup ? [`       ${entry.outgoingDelivery.setup}`] : []),
-    ...(warns ? ["       Allow development channels when prompted; check the client's startup notice."] : []),
-    ...(entry.nativeDelivery.state !== "eligible"
-      ? ["       Save consent now; delivery waits for an available client service."] : []),
-    entry.capabilities?.delivery?.nextTurn === true
-      ? "  No:  use next-turn hooks (when enabled) or acc inbox."
-      : "  No:  read messages with acc inbox; automatic next-turn delivery is unavailable.",
-  ].join("\n");
-}
-
-/**
- * Which live policy each selected client gets.
- *
- * An explicit --delivery applies uniformly and never prompts. Otherwise a
- * recorded opt-in is kept as it was consented to, a fresh or never-activated
- * client is off unless a person answers yes here, and a dry run or a
- * non-interactive stdin/stdout makes no interactive choice at all.
- */
-export async function decideDelivery({ options, detected, recorded, runtime, dryRun }) {
-  const explicit = options.delivery;
-  if (explicit !== undefined && !LIVE_POLICIES.includes(explicit)) {
-    throw new AccError(EXIT.USAGE, `unknown delivery policy: ${explicit}`, { delivery: explicit });
-  }
-  const recordedById = new Map(recorded.map(install => [install.adapterId, install]));
-  const deliveryByAdapter = {};
-  const asked = [];
-  let withheld = 0;
-  for (const entry of detected) {
-    const eligible = entry.nativeDelivery?.state === "eligible"
-      || entry.nativeDelivery?.consentAvailable === true;
-    const previous = livePolicyOf(recordedById.get(entry.adapterId));
-    if (explicit !== undefined) {
-      deliveryByAdapter[entry.adapterId] = explicit;
-    } else if (previous !== "off") {
-      deliveryByAdapter[entry.adapterId] = previous;
-    } else if (!eligible || dryRun || !isInteractive(runtime)) {
-      deliveryByAdapter[entry.adapterId] = "off";
-      if (eligible) withheld += 1;
-    } else {
-      const yes = await runtime.confirm(questionFor(entry),
-        { input: runtime.input, output: runtime.output }) === true;
-      deliveryByAdapter[entry.adapterId] = yes ? "actionable" : "off";
-      asked.push(entry.adapterId);
-    }
-  }
-  const notes = explicit === undefined && dryRun && withheld > 0
-    ? ["interactive choices were not made: this preview keeps native delivery off for "
-      + `${withheld} eligible client(s) without a recorded opt-in`]
-    : [];
-  return { deliveryByAdapter, asked, notes };
-}
-
 // Said once, after the first PATH block is written: a running shell and a
 // running client know nothing about it.
 function reloadAdvice(operations) {
@@ -315,7 +255,9 @@ export async function runInstallCommand({ options, runtime, action = "install" }
     : { deliveryByAdapter: {}, asked: [], notes: [] };
   const plan = planInstallation({ adapters, detected, context, action, recorded,
     accVersion, allowDowngrade: options.downgrade === true, requested,
-    deliveryByAdapter: decided.deliveryByAdapter });
+    deliveryByAdapter: decided.deliveryByAdapter,
+    deliveryDecisionByAdapter: decided.deliveryDecisionByAdapter,
+    allowServiceSetup: action === "install" });
   const apply = (paths = {}) => applyPlan({ plan, adapters, context: { ...context, ...paths },
     dataHome, dryRun, accVersion, activation: { bootstrap: paths.bootstrap } });
   const result = action === "install" && !dryRun && runtime.packageRoot
@@ -328,16 +270,18 @@ export async function runInstallCommand({ options, runtime, action = "install" }
 
   const acted = actedOn(result);
   if (dryRun) {
-    return { data: { ...result, plan, dataHome, deliveryByAdapter: decided.deliveryByAdapter },
+    return { data: { ...result, plan, dataHome, deliveryByAdapter: decided.deliveryByAdapter,
+      deliveryDecisionByAdapter: decided.deliveryDecisionByAdapter },
       text: [`would ${action}:`, ...plan.operations.flatMap(operation => operation.summary),
         ...plan.skipped.map(entry => `skip ${entry.adapterId}: ${entry.reason}`),
         ...decided.notes].join("\n") };
   }
 
   return { data: { ...result, plan, dataHome, deliveryByAdapter: decided.deliveryByAdapter,
-    asked: decided.asked },
+    deliveryDecisionByAdapter: decided.deliveryDecisionByAdapter, asked: decided.asked },
   text: [describeOutcome({ action, acted, failed: result.failed,
     skipped: plan.skipped, operations: result.operations, home }),
   ...reloadAdvice(result.operations)].join("\n"),
-  error: failureOf({ action, acted, failed: result.failed }) };
+  error: failureOf({ action, acted, failed: result.failed, operations: result.operations,
+    skipped: plan.skipped, home }) };
 }

package/node_modules/@agents-can-communicate/cli/src/install-delivery-consent.mjs

@@ -0,0 +1,152 @@
+import { LIVE_POLICIES, livePolicyOf } from "@agents-can-communicate/installer";
+import { AccError, EXIT } from "@agents-can-communicate/protocol";
+
+const DECISION_SOURCES = new Set([
+  "interactive-accepted",
+  "interactive-declined",
+  "explicit-option",
+  "noninteractive-default",
+  "unsupported-default",
+  "legacy-unknown",
+]);
+const DELIBERATE_SOURCES = new Set([
+  "interactive-accepted", "interactive-declined", "explicit-option",
+]);
+
+const legacyDecision = () => ({ source: "legacy-unknown", completeSetup: false });
+
+function validDecision(record) {
+  const decision = record?.deliveryDecision;
+  if (!(decision !== null && typeof decision === "object"
+    && DECISION_SOURCES.has(decision.source)
+    && typeof decision.completeSetup === "boolean")) return false;
+
+  const enabled = livePolicyOf(record) !== "off";
+  if (decision.source === "interactive-accepted") return decision.completeSetup && enabled;
+  if (decision.source === "interactive-declined") return !decision.completeSetup && !enabled;
+  if (decision.source === "explicit-option") return decision.completeSetup === enabled;
+  if (["noninteractive-default", "unsupported-default"].includes(decision.source)) {
+    return !decision.completeSetup && !enabled;
+  }
+  return decision.completeSetup === false;
+}
+
+export function decisionOf(record) {
+  return validDecision(record)
+    ? { source: record.deliveryDecision.source,
+      completeSetup: record.deliveryDecision.completeSetup }
+    : legacyDecision();
+}
+
+const isEligible = entry => entry.nativeDelivery?.state === "eligible"
+  || entry.nativeDelivery?.consentAvailable === true;
+
+const needsExpandedSetup = entry => ["needed", "blocked"]
+  .includes(entry.nativeServiceSetup?.state);
+
+const isInteractive = runtime => typeof runtime.isInteractive === "function"
+  && runtime.isInteractive() === true;
+
+function questionFor(entries) {
+  const names = entries.map(entry => entry.displayName ?? entry.adapterId).join(", ");
+  const setup = [...new Set(entries.map(entry => entry.outgoingDelivery?.setup)
+    .filter(value => typeof value === "string"))];
+  const channels = entries.some(entry => (entry.nativeDelivery?.activationPlan?.mechanisms ?? [])
+    .some(mechanism => mechanism.kind === "shell-bootstrap"
+      && (mechanism.prefixArgs ?? []).some(argument => argument.startsWith("--"))));
+  return [
+    `Complete automatic peer-request setup for ${names}? (experimental)`,
+    "  Yes: automatic turns can spend tokens without waiting for you.",
+    "       Configure the required local permission grants.",
+    ...(entries.some(entry => entry.adapterId === "codex")
+      ? ["       Start a missing supported Codex service."] : []),
+    ...setup.map(note => `       ${note}`),
+    ...(channels ? ["       Allow Claude Code development Channels when prompted at startup."] : []),
+    "  No: keep current delivery policies and use available next-turn hooks or acc inbox.",
+  ].join("\n");
+}
+
+/** Decide delivery once for all clients whose complete setup has no recorded answer. */
+export async function decideDelivery({ options, detected, recorded, runtime, dryRun }) {
+  const explicit = options.delivery;
+  if (explicit !== undefined && !LIVE_POLICIES.includes(explicit)) {
+    throw new AccError(EXIT.USAGE, `unknown delivery policy: ${explicit}`, { delivery: explicit });
+  }
+
+  const recordedById = new Map(recorded.map(install => [install.adapterId, install]));
+  const deliveryByAdapter = {};
+  const deliveryDecisionByAdapter = {};
+  const candidates = [];
+  let withheld = 0;
+
+  for (const entry of detected) {
+    const record = recordedById.get(entry.adapterId);
+    const previous = livePolicyOf(record);
+    const eligible = isEligible(entry);
+
+    if (explicit !== undefined) {
+      deliveryByAdapter[entry.adapterId] = explicit;
+      deliveryDecisionByAdapter[entry.adapterId] = {
+        source: "explicit-option", completeSetup: explicit !== "off",
+      };
+      continue;
+    }
+
+    deliveryByAdapter[entry.adapterId] = previous;
+    if (record !== undefined) {
+      deliveryDecisionByAdapter[entry.adapterId] = decisionOf(record);
+    }
+
+    if (!eligible) {
+      deliveryDecisionByAdapter[entry.adapterId] ??= {
+        source: "unsupported-default", completeSetup: false,
+      };
+      continue;
+    }
+
+    const alreadyDecided = validDecision(record)
+      && DELIBERATE_SOURCES.has(record.deliveryDecision.source);
+    const expandsLegacyOptIn = previous !== "off" && needsExpandedSetup(entry)
+      && !decisionOf(record).completeSetup;
+    const freshDecision = previous === "off" && !alreadyDecided;
+    if (!freshDecision && !expandsLegacyOptIn) {
+      deliveryDecisionByAdapter[entry.adapterId] ??= legacyDecision();
+      continue;
+    }
+
+    if (dryRun || !isInteractive(runtime)) {
+      if (record === undefined) {
+        deliveryDecisionByAdapter[entry.adapterId] = {
+          source: "noninteractive-default", completeSetup: false,
+        };
+      }
+      if (dryRun && freshDecision) withheld += 1;
+      continue;
+    }
+    candidates.push(entry);
+  }
+
+  const asked = candidates.map(entry => entry.adapterId);
+  if (candidates.length > 0) {
+    const yes = await runtime.confirm(questionFor(candidates),
+      { input: runtime.input, output: runtime.output }) === true;
+    for (const entry of candidates) {
+      const record = recordedById.get(entry.adapterId);
+      const previous = livePolicyOf(record);
+      deliveryByAdapter[entry.adapterId] = yes
+        ? (previous === "off" ? "actionable" : previous)
+        : previous;
+      deliveryDecisionByAdapter[entry.adapterId] = yes
+        ? { source: "interactive-accepted", completeSetup: true }
+        : previous === "off"
+          ? { source: "interactive-declined", completeSetup: false }
+          : decisionOf(record);
+    }
+  }
+
+  const notes = explicit === undefined && dryRun && withheld > 0
+    ? ["interactive choices were not made: this preview keeps native delivery off for "
+      + `${withheld} eligible client(s) without a recorded opt-in`]
+    : [];
+  return { deliveryByAdapter, deliveryDecisionByAdapter, asked, notes };
+}

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

@@ -18,11 +18,16 @@ export async function prepareRefresh({ control, root, env = process.env, callerP
   const detected = await detectInstallation({ adapters, context, probeTimeoutMs: probeTimeout(env) });
   const deliveryByAdapter = Object.fromEntries(adapters.map(adapter => [adapter.id,
     livePolicyOf(recorded.find(record => record.adapterId === adapter.id))]));
+  const deliveryDecisionByAdapter = Object.fromEntries(adapters.flatMap(adapter => {
+    const decision = recorded.find(record => record.adapterId === adapter.id)?.deliveryDecision;
+    return decision === undefined ? [] : [[adapter.id, decision]];
+  }));
   // Refresh configuration even when the client's service is temporarily absent.
   // The installer preserves consent and existing activation; readiness stays a
   // separate, current probe result rather than an update prerequisite.
   const plan = planInstallation({ adapters, detected, context, recorded,
-    accVersion: control.pending.version, requested: control.targets, deliveryByAdapter });
+    accVersion: control.pending.version, requested: control.targets, deliveryByAdapter,
+    deliveryDecisionByAdapter });
   if (plan.skipped.length || plan.operations.length !== wanted.size) {
     throw new Error("candidate did not plan every installed integration");
   }

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

@@ -1,5 +1,13 @@
 import { describeNativeReason } from "@agents-can-communicate/installer";
 
+export function describeDeliveryDecision(decision) {
+  if (decision?.source === "interactive-declined") return "declined during interactive setup";
+  if (decision?.source === "explicit-option") return "disabled by explicit option";
+  if (decision?.source === "noninteractive-default") return "defaulted off in a noninteractive run";
+  if (decision?.source === "unsupported-default") return "defaulted off because delivery was unsupported";
+  return "origin unknown (legacy install)";
+}
+
 export function describeNative(native, { clientVersion } = {}) {
   const differs = native.runtime === "active" && native.sessionPolicy
     && native.sessionPolicy !== native.policy;
@@ -20,24 +28,33 @@ export function nativeRemediation(entry) {
   const native = entry.nativeDelivery;
   if (!(entry.present || entry.installed) || native.eligibility === "unsupported") return [];
   const steps = [];
+  const service = entry.nativeServiceSetup;
   if (!native.configured && native.runtime !== "active") {
     steps.push(`acc install --adapter ${entry.adapterId} --delivery actionable`
       + "  # 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");
-  } else if (native.configured && native.runtime !== "active") {
+  } else if (native.configured && native.runtime !== "active"
+    && !["needed", "blocked"].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; "
       + "then run acc doctor here");
   }
   if (native.reasonCode === "native_endpoint_unavailable") {
-    steps.push(entry.nativeSetup ?? `${entry.displayName}: check the client's local delivery service setup; `
-      + "ACC does not start or restart that service");
-  } else if (native.reasonCode === "native_session_unavailable") {
+    if (service?.state === "blocked") steps.push(service.diagnostic);
+    else if (service?.state === "needed" && native.configured) {
+      steps.push(entry.deliveryDecision?.completeSetup === true
+        ? `acc install --adapter ${entry.adapterId}  # prepare the missing supported local service`
+        : `acc install --adapter ${entry.adapterId} --delivery actionable`
+          + "  # approve complete automatic peer-request setup");
+    } else if (service?.state !== "needed" && service?.state !== "ready") {
+      steps.push(entry.nativeSetup ?? `${entry.displayName}: check the client's local delivery service setup`);
+    }
+  } else if (native.reasonCode === "native_session_unavailable" && native.runtime !== "active") {
     steps.push(`${entry.displayName}: open a session connected to the client's local delivery service`);
   }
-  return steps;
+  return [...new Set(steps)];
 }
 
 // One closed native-delivery report per adapter, built only from detection,

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

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

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

@@ -110,6 +110,12 @@ export function createInboxService(ports, sessions) {
     const now = clock.now();
     return store.transaction(async tx => {
       await requireOpen(input, "acknowledge a message", tx);
+      const { message, receipt } = requireOwnedReceipt(tx, session, input.messageId);
+      if (message.obligation === "reply" && receipt.state !== "acknowledged") {
+        throw new AccError(EXIT.CONFLICT,
+          "this message requires a reply; use reply to answer, clarify, or decline",
+          { messageId: input.messageId, obligation: message.obligation });
+      }
       return advanceOwned(tx, session, input.messageId, "acknowledged", now).receipt;
     }, { kinds: ["session", "message", "receipt"] });
   }
@@ -120,14 +126,8 @@ export function createInboxService(ports, sessions) {
     const replyId = ids.next("message");
     return store.transaction(tx => {
       const original = requireOwnedReceipt(tx, session, input.messageId);
-      const matchingReply = tx.list("message", message =>
-        message.workspaceId === session.workspaceId
-        && message.fromParticipantId === session.participantId
-        && message.clientMessageId === input.clientMessageId).at(0);
-      if (original.receipt.state === "acknowledged" && matchingReply === undefined) {
-        throw new AccError(EXIT.CONFLICT, "that message is already resolved",
-          { messageId: input.messageId });
-      }
+      // A receipt settles delivery, not the conversation. Distinct replies may
+      // follow an ack or an earlier answer; recording still enforces retry keys.
       const recorded = recordMessageInTransaction({ tx, session, now, messageId: replyId, ids,
         action: "reply to a message", input: {
           clientMessageId: input.clientMessageId,

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

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

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

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

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

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

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

@@ -1,3 +1,4 @@
+import { applyServiceSetup } from "./service-setup.mjs";
 import { applyNativeActivation, deactivateNative } from "./native-activation.mjs";
 import { finalizeRemoval, missingArtifactParents, recordInstall,
   removeEmptyOwnedDirectories, removeOwnedArtifacts } from "./ownership.mjs";
@@ -68,7 +69,8 @@ export async function applyPlan({ plan, adapters, context, dataHome, dryRun = fa
         await recordInstall({ dataHome, adapterId: adapter.id,
           version: operation.clientVersion ?? null, accVersion,
           artifacts: operation.artifacts, createdDirectories,
-          deliveryPolicy: operation.livePolicy, nativeActivation: native });
+          deliveryPolicy: operation.livePolicy, deliveryDecision: operation.deliveryDecision,
+          nativeActivation: native });
         results.operations.push({ ...operation, applied: true, appendedRcBlock,
           needsAction: outcome.needsAction ?? [],
           changes: outcome.changes ?? [], diagnostics: [
@@ -77,6 +79,8 @@ export async function applyPlan({ plan, adapters, context, dataHome, dryRun = fa
             ...(outcome.diagnostics ?? []),
             ...notes,
           ] });
+        await applyServiceSetup({ adapter, context: installContext,
+          operation: results.operations.at(-1), results });
       } else {
         // Config ownership can veto removal. Ask before teardown or recorded
         // artifact deletion; an adapter-local check would run after those writes.
@@ -131,7 +135,7 @@ function describeTeardown(report) {
   for (const service of report.services) {
     lines.push(service.outcome === "stopped" ? `stopped the ${service.serviceId} service`
       : `retained the ${service.serviceId} service (${service.outcome === "retained_pre_existing"
-        ? "it existed before ACC" : "no vendor teardown exists"})`);
+        ? "it was reused at activation" : "no vendor teardown exists"})`);
   }
   return lines;
 }

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

@@ -145,6 +145,17 @@ export async function detectInstallation({ adapters, context, probe = spawnProbe
         : unsupported(adapter.nativeDelivery === undefined
           ? "native_delivery_unsupported" : "version_unavailable");
 
+      if (entry.present && typeof adapter.inspectNativeServiceSetup === "function") {
+        try {
+          entry.nativeServiceSetup = await withTimeout(Promise.resolve().then(() =>
+            adapter.inspectNativeServiceSetup({ ...context, platform, clientVersion: entry.version })),
+          probeTimeoutMs, `${adapter.id} service setup probe`);
+        } catch {
+          entry.nativeServiceSetup = { state: "blocked", reasonCode: "service_inspection_failed",
+            diagnostic: `${adapter.displayName} service preparation could not be inspected; check the vendor service and retry install` };
+        }
+      }
+
       try {
         const detected = await adapter.detect({ ...context, clientVersion: entry.version,
           platform, nativeDelivery: entry.nativeDelivery });

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

@@ -110,7 +110,8 @@ async function saveOwnership({ dataHome, record }) {
  * runtime, and leaves the bundle inside the client exactly where it was.
  */
 export async function recordInstall({ dataHome, adapterId, version, accVersion = null,
-  artifacts, createdDirectories = [], deliveryPolicy, nativeActivation = null }) {
+  artifacts, createdDirectories = [], deliveryPolicy, deliveryDecision,
+  nativeActivation = null }) {
   const stamped = await Promise.all(artifacts.map(async artifact => ({
     path: artifact.path,
     kind: artifact.kind ?? "file",
@@ -120,6 +121,7 @@ export async function recordInstall({ dataHome, adapterId, version, accVersion =
   })));
   const record = await loadOwnership({ dataHome });
   const previous = record.installs.find(install => install.adapterId === adapterId);
+  const retainedDeliveryDecision = deliveryDecision ?? previous?.deliveryDecision;
   const directories = [...new Set([
     ...(previous?.createdDirectories ?? []), ...createdDirectories,
   ])].sort((left, right) => left.split(path.sep).length - right.split(path.sep).length
@@ -129,6 +131,9 @@ export async function recordInstall({ dataHome, adapterId, version, accVersion =
       { adapterId, version, accVersion, artifacts: stamped,
         ...(directories.length === 0 ? {} : { createdDirectories: directories }),
         ...(deliveryPolicy === undefined ? {} : { deliveryPolicy }),
+        ...(retainedDeliveryDecision === undefined ? {} : {
+          deliveryDecision: retainedDeliveryDecision,
+        }),
         // Present only for a consented native activation. A record without it
         // - every 0.2 install - reads as live policy off and is never rewritten
         // merely to add the field.

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

@@ -14,7 +14,7 @@ import { LIVE_POLICIES, describeActivation, describeDeactivation, planActivation
  */
 export function planInstallation({ adapters, detected, context, action = "install",
   recorded = [], accVersion = null, allowDowngrade = false, requested = [],
-  deliveryByAdapter = {} }) {
+  deliveryByAdapter = {}, deliveryDecisionByAdapter = {}, allowServiceSetup = false }) {
   if (!["install", "uninstall"].includes(action)) {
     throw new AccError(EXIT.USAGE, `unknown installation action: ${action}`, { action });
   }
@@ -104,6 +104,9 @@ export function planInstallation({ adapters, detected, context, action = "instal
     // and so what will be removed. Asking the adapter instead would describe an
     // install for a machine this one no longer is.
     const delivery = deliveryByAdapter[entry.adapterId] ?? "off";
+    const deliveryDecision = deliveryDecisionByAdapter[entry.adapterId]
+      ?? recordedById.get(entry.adapterId)?.deliveryDecision
+      ?? { source: "legacy-unknown", completeSetup: false };
     const native = entry.nativeDelivery ?? null;
     const liveDeliverySupported = native?.state === "eligible"
       && native.activationPlan?.eligible === true;
@@ -122,8 +125,10 @@ export function planInstallation({ adapters, detected, context, action = "instal
       ? describeInstallDelivery(entry, delivery, effectiveLivePolicy) : null;
     const installContext = { ...context, requestedLivePolicy: delivery,
       livePolicy: configuredLivePolicy, clientVersion: entry.version, platform: entry.platform };
+    const nativeServiceSetup = action === "install" && allowServiceSetup && delivery !== "off"
+      && deliveryDecision.completeSetup === true ? entry.nativeServiceSetup : undefined;
     const setupNotes = action === "install" && delivery !== "off"
-      ? [entry.outgoingDelivery?.setup, entry.nativeSetup].filter(note => typeof note === "string") : [];
+      ? [entry.outgoingDelivery?.setup, nativeServiceSetup ? null : entry.nativeSetup].filter(note => typeof note === "string") : [];
     // A consented activation that this run keeps, activates, or takes back.
     // Only an explicit off or an uninstall removes one; an absent record never
     // creates one.
@@ -154,11 +159,13 @@ export function planInstallation({ adapters, detected, context, action = "instal
       alreadyInstalled: entry.installed === true,
       livePolicy: delivery,
       effectiveLivePolicy,
+      ...(action === "install" ? { deliveryDecision } : {}),
       ...(retainedActivation ? { configuredLivePolicy, retainedNativeActivation: retainedActivation } : {}),
       ...(deliveryDiagnostic === null ? {} : { deliveryDiagnostic }),
       ...(deliverySummary === null ? {} : { deliverySummary }),
       ...(setupNotes.length ? { setupNotes } : {}),
       ...(nativeActivation === null ? {} : { nativeActivation }),
+      ...(nativeServiceSetup ? { nativeServiceSetup } : {}),
       ...(deactivation === null ? {} : { deactivation }),
       artifacts,
       // Said in the operator's terms, not in paths: which files ACC creates
@@ -169,6 +176,7 @@ export function planInstallation({ adapters, detected, context, action = "instal
         ...(deliverySummary === null ? [] : [deliverySummary]),
         ...(retainedActivation ? ["keep existing native delivery setup; current readiness is unverified"] : []),
         ...setupNotes,
+        ...(nativeServiceSetup ? [nativeServiceSetup.diagnostic] : []),
         ...artifacts.filter(a => a.kind === "tree")
           .map(a => `${action === "install" ? "create" : "remove"} ${a.path}`),
         ...artifacts.filter(a => a.kind === "merge")