agents-can-communicate 0.5.3 → 0.5.5

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

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

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

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

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

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

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

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

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

@@ -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."],

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/generation-files.mjs

@@ -0,0 +1,25 @@
+import { createHash } from "node:crypto";
+import { lstat, readFile, readdir } from "node:fs/promises";
+import path from "node:path";
+
+export async function collectFile(source, relative, collected) {
+  const stat = await lstat(source);
+  if (stat.isSymbolicLink()) throw new Error(`symbolic link inside runtime files: ${relative}`);
+  if (stat.isDirectory()) {
+    for (const entry of (await readdir(source)).sort()) {
+      await collectFile(path.join(source, entry), path.posix.join(relative, entry), collected);
+    }
+  } else if (stat.isFile()) {
+    collected.set(relative, { bytes: await readFile(source), mode: stat.mode & 0o777 });
+  } else throw new Error(`unsupported runtime file: ${relative}`);
+}
+
+/** This format also names existing generations; keep it stable across upgrades. */
+export function fingerprint(files) {
+  const hash = createHash("sha256");
+  for (const [name, file] of [...files].sort(([a], [b]) => a.localeCompare(b))) {
+    hash.update(JSON.stringify([name, file.mode, file.bytes.length]));
+    hash.update(file.bytes);
+  }
+  return hash.digest("hex");
+}

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

@@ -1,8 +1,8 @@
-import { createHash } from "node:crypto";
 import { lstat, mkdir, mkdtemp, open, readFile, readdir, realpath, rename, rm }
   from "node:fs/promises";
 import path from "node:path";
 
+import { collectFile, fingerprint } from "./generation-files.mjs";
 import { attachStagingTemp, holdStagedGeneration, releaseStagingHold } from "./staging.mjs";
 
 const NAME = "agents-can-communicate";
@@ -37,18 +37,6 @@ function declaredPath(value) {
   return value.replace(/\/+$/, "");
 }
 
-async function collectFile(source, relative, collected) {
-  const stat = await lstat(source);
-  if (stat.isSymbolicLink()) throw new Error(`symbolic link inside runtime files: ${relative}`);
-  if (stat.isDirectory()) {
-    for (const entry of (await readdir(source)).sort()) {
-      await collectFile(path.join(source, entry), path.posix.join(relative, entry), collected);
-    }
-  } else if (stat.isFile()) {
-    collected.set(relative, { bytes: await readFile(source), mode: stat.mode & 0o777 });
-  } else throw new Error(`unsupported runtime file: ${relative}`);
-}
-
 async function checkDeclaredComponents(source, relative) {
   let current = source;
   for (const component of relative.split("/")) {
@@ -84,15 +72,6 @@ async function collectPackage(source, prefix, collected, expectedName, version)
   return manifest;
 }
 
-function fingerprint(files) {
-  const hash = createHash("sha256");
-  for (const [name, file] of [...files].sort(([a], [b]) => a.localeCompare(b))) {
-    hash.update(JSON.stringify([name, file.mode, file.bytes.length]));
-    hash.update(file.bytes);
-  }
-  return hash.digest("hex");
-}
-
 async function existingMatches(target, files) {
   try {
     const actual = new Map();

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

@@ -4,7 +4,7 @@ import path from "node:path";
 import { ENTRY_KINDS } from "./entry.mjs";
 import { managedDirectory, syncDirectory } from "./state.mjs";
 
-const MODULES = ["entry.mjs", "state.mjs", "mutex.mjs", "leases.mjs", "schedule.mjs", "policy.mjs"];
+const MODULES = ["entry.mjs", "state.mjs", "generation-files.mjs", "mutex.mjs", "leases.mjs", "schedule.mjs", "policy.mjs"];
 async function durableFile(file, bytes, mode = 0o600) {
   const handle = await open(file, "wx", mode);
   try { await handle.writeFile(bytes); await handle.sync(); }

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

@@ -49,11 +49,11 @@ export async function listRuntimeHolds(root, { pidIsAlive = defaultPidIsAlive }
       || typeof lease.token !== "string" || name !== `${lease.token}.json`
       || typeof lease.kind !== "string" || !lease.kind
       || !Number.isFinite(Date.parse(lease.createdAt))) throw new Error("invalid runtime lease");
-    await validateRuntime(root, lease.runtime);
+    const runtime = await validateRuntime(root, lease.runtime);
     if (await confirmedDead(lease.pid, pidIsAlive)) {
       await rm(file, { force: true });
       removed = true;
-    } else holds.push(lease);
+    } else holds.push({ ...lease, runtime });
   }
   if (removed) await syncDirectory(directory);
   return holds;

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/managed-runtime/state.mjs

@@ -2,6 +2,7 @@ import { randomUUID } from "node:crypto";
 import { constants } from "node:fs";
 import { lstat, mkdir, open, realpath, rename, rm } from "node:fs/promises";
 import path from "node:path";
+import { collectFile, fingerprint } from "./generation-files.mjs";
 
 /** Resolve existing ancestors without creating an uninitialized manager. */
 export async function canonicalManagerRoot(root) {
@@ -74,6 +75,25 @@ export async function writeManagedJson(file, value) {
 const nonempty = value => typeof value === "string" && value.length > 0;
 const nullableString = value => value === null || nonempty(value);
 
+/** Older updaters dropped the contract while publishing a newer generation.
+ * Recover only from that exact, unchanged generation, never from the active
+ * version or a loose manifest. Explicit lease declarations remain historical
+ * facts. Missing or damaged files leave an unknown hold without failing hooks.
+ */
+async function recoverStoreVersion(generations, runtime) {
+  if (path.dirname(runtime.root) !== generations
+    || !/^\d+\.\d+\.\d+-[a-f0-9]{24}$/.test(path.basename(runtime.root))) return null;
+  try {
+    const files = new Map();
+    await collectFile(runtime.root, "", files);
+    if (path.basename(runtime.root) !== `${runtime.version}-${fingerprint(files).slice(0, 24)}`) return null;
+    const manifest = JSON.parse(files.get("package.json")?.bytes.toString("utf8"));
+    return manifest.name === "agents-can-communicate" && manifest.version === runtime.version
+      && Number.isSafeInteger(manifest.accStoreVersion) && manifest.accStoreVersion > 0
+      ? manifest.accStoreVersion : null;
+  } catch { return null; }
+}
+
 export async function validateRuntime(root, runtime) {
   if (!runtime || !nonempty(runtime.version) || typeof runtime.root !== "string"
     || !path.isAbsolute(runtime.root)) throw new Error("invalid control generation");
@@ -95,7 +115,9 @@ export async function validateRuntime(root, runtime) {
   if (await managedDirectory(generations)) {
     if (await realpath(generations) !== generations) throw new Error("invalid control generations directory");
   }
-  return { version: runtime.version, root: resolved, storeVersion: runtime.storeVersion ?? null };
+  const normalized = { version: runtime.version, root: resolved, storeVersion: runtime.storeVersion ?? null };
+  normalized.storeVersion ??= await recoverStoreVersion(generations, normalized);
+  return normalized;
 }
 
 async function validateControl(root, value) {

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.3",
+  "version": "0.5.5",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/delivery-router",
-  "version": "0.5.3",
+  "version": "0.5.5",
   "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.3",
+  "version": "0.5.5",
   "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.3",
+  "version": "0.5.5",
   "private": true,
   "type": "module",
   "exports": {