agents-can-communicate 0.8.4 → 0.9.0

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

@@ -8,20 +8,22 @@ import { capabilityEvidence, clearNativeAttempt, clearSessionBinding, effectiveC
   loadSessionBinding, normalizedEvent, storeSessionBinding }
   from "@agents-can-communicate/adapter-sdk";
 import { createCoordinationService } from "@agents-can-communicate/core";
-import { loadOwnership } from "@agents-can-communicate/installer";
+import { loadOwnership } from "@agents-can-communicate/installer/hook-support";
 import { AccError, createId } from "@agents-can-communicate/protocol";
 import { openFilesystemStore } from "@agents-can-communicate/storage-filesystem";
 import { clearPin, createGitProbe, resolveHookWorkspace, platformDataHome, runtimePaths,
   writePin as writeRuntimePin }
-  from "@agents-can-communicate/cli";
+  from "@agents-can-communicate/cli/hook-support";
 
-import { resolveClientPid } from "./client-pid.mjs";
-import { probeClientVersion as defaultProbeClientVersion } from "./client-version.mjs";
+import { resolveClient } from "./client-pid.mjs";
+import { ownExecutable, probeClientVersion as defaultProbeClientVersion, probeExecutableVersion }
+  from "./client-version.mjs";
 import { bindNative, callRelease, nativeActivationHintFor, nativeDiagnosticDeadline }
   from "./native-attempt.mjs";
 import { readProcessTable as defaultReadProcessTable } from "./process-table.mjs";
 import { withSessionLifecycle } from "./session-lifecycle.mjs";
-import { appendStartOwner, appendToolOwner, ownerHeader, ownerOnlyOutcome } from "./owner-context.mjs";
+import { appendStartOwner, appendToolOwner, assertOwnerQuotable, ownerHeader, ownerOnlyOutcome }
+  from "./owner-context.mjs";
 
 // Kept cohesive above 300 lines because every handler shares one fail-open
 // hook boundary, binding lifecycle, and client-specific outcome contract.
@@ -31,6 +33,16 @@ import { appendStartOwner, appendToolOwner, ownerHeader, ownerOnlyOutcome } from
 // A hook runs in front of the user's turn, so it gets a hard ceiling. Better to
 // let a call through than to make someone's session sit waiting on us.
 const DEFAULT_BUDGET_MS = 5_000;
+// Failures the hook output explains with advice of its own; any other error
+// text stays out of what the client shows.
+const KNOWN_FAILURES = new Set(["workspace_contains_runtime", "workspace_path_unquotable"]);
+// Windows reads the table through WMI in Script Host, 145 ms on a
+// windows-latest runner, and through PowerShell where Script Host is off, whose
+// first start on a machine took 3.8 s. It gets more of the budget there, and
+// leaves the rest for the write that follows.
+const WINDOWS = process.platform === "win32";
+const PROCESS_TABLE_MS = WINDOWS ? 3_000 : 1_000;
+const TABLE_RESERVE_MS = WINDOWS ? 500 : 0;
 
 function assertHookBudget(deadline, message = "hook deadline expired") {
   if (Date.now() >= deadline) throw new Error(message);
@@ -238,8 +250,8 @@ async function openContext({ event, adapterId, dataHome, runtime, env, deadline
 // offered. Runs after the heartbeat and the bounded native retry.
 // `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, repeats = true }) {
+async function projectTurn({ binding, context, adapter, adapterId, render = null,
+  activationHint = null, activationNotice = null, repeats = true }) {
   const sync = await context.service.sync({ sessionId: binding.accSessionId,
     cursor: null, scope: "delta" });
 
@@ -283,11 +295,17 @@ async function projectTurn({ binding, context, adapter, adapterId,
   const owner = hintFits ? `${header}\n${activationHint}` : header;
   const withHint = (outcome, attached) => ({ ...outcome,
     activationHintIncluded: attached === true && outcome.stdout !== "" });
+  // The ask's line for the user travels with its line for the model, or not
+  // at all: the adapter shows it where the client shows a hook's message.
+  const notice = hintFits && activationNotice !== null ? { userMessage: activationNotice } : null;
+  const inject = text => notice === null ? adapter.injectOutcome?.(text)
+    : adapter.injectOutcome?.(text, notice);
+  const renderText = render ?? inject;
   // A peer can join after this prompt has begun. The current turn must already
   // have its own arguments when it needs inbox/reply, without reattaching or
   // waiting for another user prompt. Solo emits identity, not a peer notice.
   if (sync.solo && messages.length === 0) {
-    return withHint(ownerOnlyOutcome(text => adapter.injectOutcome?.(text), owner, totalBudget),
+    return withHint(ownerOnlyOutcome(inject, owner, totalBudget),
       hintFits);
   }
 
@@ -336,7 +354,7 @@ async function projectTurn({ binding, context, adapter, adapterId,
   // Own claims make sync non-solo but produce no peer context. They cannot
   // remove this turn's identity or consume a nonexistent body separator.
   if (body === "" && messages.length === 0) {
-    return withHint(ownerOnlyOutcome(text => adapter.injectOutcome?.(text), owner, totalBudget),
+    return withHint(ownerOnlyOutcome(inject, owner, totalBudget),
       hintFits);
   }
   const projected = body === "" ? "" : ownerFits ? `${owner}\n${body}` : body;
@@ -361,7 +379,7 @@ async function projectTurn({ binding, context, adapter, adapterId,
   // The entry point owns the transport boundary. This handler only prepares
   // offer inputs; recording them here would claim delivery before stdout's
   // callback proves that the bytes crossed.
-  const outcome = { stdout: "", ...render(projected) };
+  const outcome = { stdout: "", ...renderText(projected) };
   const writableOffers = outcome.stdout === "" ? [] : offerInputs;
   return withHint({ ...outcome,
     stderr: [outcome.stderr, ownerWarning, degradation].filter(Boolean).join("\n"),
@@ -373,7 +391,8 @@ async function projectTurn({ binding, context, adapter, adapterId,
 // so the reservation goes with it.
 async function projectActivation(input, offered) {
   try {
-    const turn = await projectTurn({ ...input, activationHint: offered?.line ?? null });
+    const turn = await projectTurn({ ...input, activationHint: offered?.line ?? null,
+      activationNotice: offered?.userMessage ?? null });
     const included = turn.activationHintIncluded === true;
     delete turn.activationHintIncluded;
     if (!offered) return turn;
@@ -389,13 +408,71 @@ async function projectActivation(input, offered) {
   }
 }
 
+const STABLE_OR_PRERELEASE = /^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/;
+const isVersion = value => typeof value === "string" && STABLE_OR_PRERELEASE.test(value);
+
+/**
+ * Which of its products the adapter recognised the client as. A variant name
+ * the adapter does not declare is ignored together with the version it came
+ * with: that version counts on a line ACC has no evidence for.
+ */
+function declaredProduct(adapter, client) {
+  const name = client?.certificationName;
+  if (typeof name !== "string") return { clientName: undefined, version: client?.version };
+  const primary = adapter.client?.certificationName ?? adapter.client?.command;
+  if (name === primary) return { clientName: undefined, version: client.version };
+  const declared = (adapter.client?.variants ?? []).some(variant => variant?.certificationName === name);
+  return declared ? { clientName: name, version: client.version }
+    : { clientName: undefined, version: undefined };
+}
+
+/**
+ * The version the session's own client runs, or null to fall back to the PATH
+ * probe: what its command line named, then the adapter's reading of the
+ * running client (Claude Code's session registry), then the client's own
+ * executable when `ps` names it by full path. Each step is bounded by the
+ * hook's budget and fails open.
+ */
+async function runningClientVersion({ adapter, client, product, env, deadline }) {
+  if (client === null || client === undefined) return null;
+  if (isVersion(product.version)) return product.version;
+  const remaining = cap => Math.max(1, Math.min(cap, deadline - Date.now() - TABLE_RESERVE_MS));
+  if (typeof adapter.clientVersionOf === "function" && client.entry !== undefined) {
+    let timer;
+    const read = await Promise.race([
+      Promise.resolve().then(() => adapter.clientVersionOf({ pid: client.pid, entry: client.entry, env }))
+        .catch(() => null),
+      new Promise(resolve => { timer = setTimeout(() => resolve(null), remaining(500)); }),
+    ]).finally(() => clearTimeout(timer));
+    if (isVersion(read)) return read;
+  }
+  const file = ownExecutable(client.entry, adapter.client?.command);
+  if (file === null) return null;
+  return probeExecutableVersion(file, adapter.client?.versionArgs ?? ["--version"],
+    { timeoutMs: remaining(1_000) });
+}
+
+// Whether the client process a binding names has exited. Signal 0 delivers
+// nothing; EPERM means the process exists under another user.
+function clientGone(binding) {
+  const pid = binding?.clientPid;
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    process.kill(pid, 0);
+    return false;
+  } catch (error) {
+    return error?.code === "ESRCH";
+  }
+}
+
 const HANDLERS = {
   // `knownClientPid` and `pins: false` are registration's (#167): it runs in
   // a peer's process, so the client's pid is handed over rather than found in
   // this process's ancestry, and it pins nothing because no hook code of any
   // generation runs for the session until its first real hook pins its own.
   async sessionStart({ event, context, adapter, adapterId, binding, paths,
-    readProcessTable, probeClientVersion, platform, deadline, knownClientPid, pins = true }) {
+    readProcessTable, probeClientVersion, platform, deadline, knownClientPid, pins = true,
+    tableRead: started = null, mark = () => {}, clientRestarted = false }) {
     // Where this session's pin lives, resolved once and reused at every write
     // below. Beside `paths.root`, never inside it: see `managerRootFor`.
     const pinRoot = managerRootFor(context.dataHome);
@@ -412,23 +489,42 @@ const HANDLERS = {
       await writePin({ root: pinRoot, harnessSessionId: event.sessionId, runtimeRoot: facts.runtimeRoot,
         version: facts.version, storeVersion: facts.storeVersion, clientPid: binding.clientPid });
     }
-    const clientVersion = await probeClientVersion(adapter,
-      { timeoutMs: Math.max(1, Math.min(1_000, deadline - Date.now())) });
-    assertHookBudget(deadline);
-    const clientFacts = { clientVersion, platform };
-    const capabilities = effectiveCapabilities(adapter, clientFacts);
     // Once per session, never per turn. A client that cannot be found yields
     // null, and the session is then judged by age alone - which is exactly the
     // behaviour every session had before this existed.
     const command = adapter.client?.command ?? null;
-    const pid = Number.isInteger(knownClientPid) && knownClientPid > 0 ? knownClientPid
-      : command === null ? null
-      : resolveClientPid({ table: await readProcessTable({
-        timeoutMs: Math.max(1, Math.min(1_000, deadline - Date.now())) }), from: process.pid, command });
+    const known = Number.isInteger(knownClientPid) && knownClientPid > 0;
+    // Read while the client reports its version: neither needs the other, and
+    // each can start a program. A session start began the read already, when
+    // its event was known. Handled here so a probe that fails first leaves no
+    // rejection unobserved.
+    const tableRead = known || command === null ? null : started ?? Promise.resolve(readProcessTable({
+      timeoutMs: Math.max(1, Math.min(PROCESS_TABLE_MS, deadline - Date.now() - TABLE_RESERVE_MS)) }));
+    tableRead?.catch(() => {});
+    // The binary on PATH answers in parallel, as the fallback: the version the
+    // running client names for itself, when it names one, wins below.
+    const pathVersion = probeClientVersion(adapter,
+      { timeoutMs: Math.max(1, Math.min(1_000, deadline - Date.now())) });
+    mark("reading the process table");
+    const client = known ? { pid: knownClientPid } : command === null ? null
+      : resolveClient({ table: await tableRead, from: process.pid, command,
+        clientPackage: adapter.client?.package, identify: adapter.identifyClientProcess });
     assertHookBudget(deadline);
+    mark("probing the client version");
+    const product = declaredProduct(adapter, client);
+    const clientVersion = await runningClientVersion({ adapter, client, product, env: context.env,
+      deadline }) ?? await pathVersion;
+    assertHookBudget(deadline);
+    const clientFacts = { clientVersion, platform,
+      ...(product.clientName === undefined ? {} : { clientName: product.clientName }) };
+    const capabilities = effectiveCapabilities(adapter, clientFacts);
+    const pid = client?.pid ?? null;
+    mark("opening the session");
     const clientPid = Number.isInteger(pid) && pid > 0 ? pid : undefined;
-    const native = hookBinding => bindNative({ adapter, event, hookBinding, ...clientFacts,
-      context, paths, deadline });
+    const native = hookBinding => {
+      mark("binding live delivery");
+      return bindNative({ adapter, event, hookBinding, ...clientFacts, context, paths, deadline });
+    };
     const metadata = {
       pid,
       enforcement: capabilities.guards?.beforeWrite === true ? "guarded" : "advisory",
@@ -439,13 +535,18 @@ const HANDLERS = {
     };
     if (event.kind === "beforeTurn" && binding !== null) {
       // A genuine prompt can resume after an ephemeral removal or a durable
-      // close. Recheck after probes: a CLI replacement can run outside the
-      // native lifecycle lock. Never adopt that replacement's identity.
+      // close, or carry on a session whose client restarted. Recheck after
+      // probes: a CLI replacement can run outside the native lifecycle lock.
+      // Never adopt that replacement's identity.
+      // A session can also close between the turn's check and this one while
+      // its client was down; that is the closed-session resumption below,
+      // not a replacement.
       const previous = await context.service.locateSession(binding.accSessionId);
-      if (previous !== null && (previous.record.state !== "closed"
-        || previous.record.generation !== binding.generation)) {
-        throw new Error("the completed hook owner changed during turn registration");
-      }
+      const sameGeneration = previous?.record.generation === binding.generation;
+      const expected = previous === null
+        || sameGeneration && (previous.record.state === "closed"
+          || clientRestarted && previous.record.state === "open");
+      if (!expected) throw new Error("the completed hook owner changed during turn registration");
     }
     if (binding !== null) {
       const resumed = await context.service.resumeSession({
@@ -564,6 +665,21 @@ const HANDLERS = {
       const turn = await projectActivation({ ...input, binding: fresh }, offered);
       return { ...turn, nativeBinding: started.nativeBinding };
     }
+    if (clientGone(binding)) {
+      // The client this session was bound to has exited, and a turn arrived
+      // anyway: the client restarted under the same conversation. Antigravity
+      // 2.0 reopens a conversation without a second SessionStart, so without
+      // this the session stayed bound to a dead process and lost live delivery
+      // for good. The start path finds the client running now, keeps this ACC
+      // session and generation, and binds again.
+      const started = await HANDLERS.sessionStart({ ...input, clientRestarted: true });
+      const fresh = await loadSessionBinding({ runtimeDir: paths.root,
+        harnessSessionId: event.sessionId });
+      const offered = await nativeActivationHintFor({ adapter, event,
+        nativeBinding: started.nativeBinding, binding: fresh, context, paths, deadline });
+      const turn = await projectActivation({ ...input, binding: fresh }, offered);
+      return { ...turn, nativeBinding: started.nativeBinding };
+    }
     // A turn is the clearest sign a session is alive. Never a reason to fail:
     // this runs in front of somebody's prompt.
     await context.service.heartbeatSession({ sessionId: binding.accSessionId,
@@ -697,35 +813,51 @@ export async function runHook({ adapterId, payload, adapters, dataHome, env,
   const deadline = Date.now() + budgetMs;
   const fallback = { stdout: "", exitCode: 0, decision: "allow", sessions: [], deadlineAt: deadline,
     commitOffers: async () => {} };
+  // Where the hook is, so a budget that runs out can say which step held it.
+  const trail = { phase: "reading the hook event" };
+  const mark = phase => { trail.phase = phase; };
   const execute = async () => {
     assertHookBudget(deadline);
     const adapter = adapters?.[adapterId];
     if (adapter === undefined) throw new Error(`no adapter named ${adapterId}`);
 
     const event = await adapter.normalizeHook(payload, { args });
+    // A session start reads the process table once, and it depends on nothing
+    // below: it starts now, while the store opens. On Windows it is the part
+    // of a start that runs another program.
+    const tableRead = event.kind !== "sessionStart" || (adapter.client?.command ?? null) === null
+      ? null : Promise.resolve(readProcessTable({ timeoutMs: Math.max(1,
+        Math.min(PROCESS_TABLE_MS, deadline - Date.now() - TABLE_RESERVE_MS)) }));
+    tableRead?.catch(() => {});
+    mark("finding the workspace");
     const context = await openContext({ event, adapterId, dataHome, runtime, env, deadline });
+    assertOwnerQuotable(context.workspaceCwd, context.workspaceRef, String(platform).split("-")[0]);
     const handler = HANDLERS[event.kind];
     const lifecycle = ["sessionStart", "sessionEnd", "beforeTurn"].includes(event.kind);
     const invoke = async () => {
       assertHookBudget(deadline);
       if (lifecycle) {
+        mark("opening the store");
         // A previous holder may have died after journalling its session while
         // this process waited. Recover that write before interpreting its binding.
         const store = await openFilesystemStore({ root: context.paths.root, clock: runtime.clock,
           ids: runtime.ids, workspaceId: context.descriptor.id, deadlineAt: deadline });
         context.service = createCoordinationService({ store, clock: runtime.clock, ids: runtime.ids });
       }
+      mark("reading the session binding");
       const binding = await loadSessionBinding({ runtimeDir: context.paths.root,
         harnessSessionId: event.sessionId });
       assertHookBudget(deadline);
+      mark("handling the event");
       // The raw payload goes to a handler only to be handed back to the adapter
       // that produced it; nothing in core reads it.
       const result = handler === undefined ? {} : await handler({ event, context, adapter, adapterId,
         binding, paths: context.paths, payload,
-        readProcessTable, probeClientVersion, platform, deadline });
+        readProcessTable, probeClientVersion, platform, deadline, tableRead, mark });
       return appendToolOwner(appendStartOwner(result, { event, context, adapter }),
         { event, binding, context, adapter });
     };
+    if (lifecycle) mark("waiting for the session lock");
     const work = lifecycle
       ? withSessionLifecycle({ root: context.paths.root, sessionId: event.sessionId,
         clock: runtime.clock, deadlineAt: deadline }, invoke)
@@ -748,6 +880,7 @@ export async function runHook({ adapterId, payload, adapters, dataHome, env,
     };
     delete result.offerInputs;
 
+    mark("reading the status");
     const status = await context.service.collectStatus({
       workspaceId: context.descriptor.id });
     assertHookBudget(deadline);
@@ -762,15 +895,15 @@ export async function runHook({ adapterId, payload, adapters, dataHome, env,
     // final status read. Store/binding deadlines fence undecided writes; an
     // activated journal still completes under its writer lock after expiry.
     const budget = new Promise(resolve => {
-      timer = setTimeout(() => resolve({ ...fallback, timedOut: true }),
+      timer = setTimeout(() => resolve({ ...fallback, timedOut: true, phase: trail.phase }),
         Math.max(0, deadline - Date.now()));
     });
     return await Promise.race([execute(), budget]);
   } catch (error) {
     return { ...fallback, failed: true, reason: error.message,
-      ...(error instanceof AccError && error.details?.reasonCode === "workspace_contains_runtime"
-        ? { failureCode: "workspace_contains_runtime" } : {}),
-      ...(Date.now() >= deadline ? { timedOut: true } : {}) };
+      ...(error instanceof AccError && KNOWN_FAILURES.has(error.details?.reasonCode)
+        ? { failureCode: error.details.reasonCode } : {}),
+      ...(Date.now() >= deadline ? { timedOut: true, phase: trail.phase } : {}) };
   } finally {
     clearTimeout(timer);
   }

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

@@ -1,10 +1,11 @@
 {
   "name": "@agents-can-communicate/installer",
-  "version": "0.8.4",
+  "version": "0.9.0",
   "private": true,
   "type": "module",
   "exports": {
-    ".": "./src/index.mjs"
+    ".": "./src/index.mjs",
+    "./hook-support": "./src/hook-support.mjs"
   },
   "files": [
     "src/"

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

@@ -1,7 +1,10 @@
+import { isLaunchOption } from "@agents-can-communicate/adapter-sdk";
+
 // Shared presentation of observed delivery facts. Vendor probes provide closed
 // reasons; installation and doctor must not turn a version floor into readiness.
 const REASONS = Object.freeze({
-  native_delivery_unsupported: "this adapter has no native delivery channel",
+  // Said of a client that has no live channel ACC supports.
+  native_delivery_unsupported: "this client has no live delivery channel ACC supports here",
   version_unavailable: "the client version could not be verified",
   below_minimum_version: "the client is below the native delivery minimum version",
   known_bad_version: "this client version has a known native delivery failure",
@@ -16,10 +19,16 @@ const REASONS = Object.freeze({
     + "cannot reach",
 });
 
-export function describeNativeReason(reason, { clientVersion, minimumVersion } = {}) {
+export function describeNativeReason(reason, { clientVersion, minimumVersion, launchOption } = {}) {
   if (reason === "below_minimum_version" && clientVersion && minimumVersion) {
     return `client ${clientVersion} needs version ${minimumVersion} or newer for native delivery`;
   }
+  // A client can run embedded because of how it was started - Codex does for
+  // `--search`, `-c`, `--profile` and others while its daemon runs.
+  if (reason === "client_session_embedded" && isLaunchOption(launchOption)) {
+    return `the client was started with ${launchOption}, which runs this session on its own `
+      + "embedded service that peers cannot reach";
+  }
   return REASONS[reason] ?? reason ?? "readiness is unverified";
 }
 export const describeDeliveryFallback = entry => entry.capabilities?.delivery?.nextTurn === true

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

@@ -1,8 +1,8 @@
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
 
-import { capabilityEvidence, effectiveCapabilities, evaluateNativeEligibility,
-  validateNativeActivationPlan }
+import { capabilityEvidence, effectiveCapabilities, evaluateNativeEligibility, mergeEnv, pathOf,
+  resolveExecutable as resolveOnPath, runExecutable, validateNativeActivationPlan }
   from "@agents-can-communicate/adapter-sdk";
 
 import { resolveExecutable, shimDirFor } from "./native-activation.mjs";
@@ -34,6 +34,14 @@ const VERSION = /(?:^|[^0-9A-Za-z])v?(\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?)(?:\b
 // `env` decides where the command is looked up, so detection given an
 // environment finds the client on that environment's PATH.
 export const spawnProbe = async (command, args, { env } = {}) => {
+  // Windows finds `codex.cmd` or `claude.exe`, never the bare name, and starts a
+  // .cmd only through cmd.exe.
+  if (process.platform === "win32") {
+    const file = await resolveOnPath(command, { pathEnv: pathOf(env ?? process.env) });
+    if (file === null) throw Object.assign(new Error(`${command} is not on PATH`), { code: "ENOENT" });
+    const { stdout, stderr } = await runExecutable(file, args, env === undefined ? {} : { env });
+    return `${stdout}${stderr}`.trim();
+  }
   const { stdout, stderr } = await run(command, args, env === undefined ? {} : { env });
   return `${stdout}${stderr}`.trim();
 };
@@ -128,7 +136,7 @@ export async function detectInstallation({ adapters, context, probe = spawnProbe
           // own environment must not find a different client, or none.
           Promise.resolve(probe(adapter.client.command,
             adapter.client.versionArgs ?? ["--version"],
-            { env: context?.env === undefined ? undefined : { ...process.env, ...context.env } })),
+            { env: context?.env === undefined ? undefined : mergeEnv(process.env, context.env) })),
           probeTimeoutMs, `${adapter.id} version probe`);
         if (typeof output === "string" && output !== "") {
           entry.present = true;
@@ -167,6 +175,8 @@ export async function detectInstallation({ adapters, context, probe = spawnProbe
         if (detected.inboundDelivery) entry.inboundDelivery = detected.inboundDelivery;
         // Whether the client asks before each ACC command, and what would stop it.
         if (detected.commandApproval) entry.commandApproval = detected.commandApproval;
+        // Whether the command that starts live delivery asks first.
+        if (detected.relayApproval) entry.relayApproval = detected.relayApproval;
         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/hook-support.mjs

@@ -0,0 +1,5 @@
+// What a hook reads from the installation record, without the installer: the
+// package index loads detection, planning and application, which a hook never
+// runs, on every turn.
+export { loadOwnership } from "./ownership.mjs";
+export { readInstalledLivePolicyState } from "./live-policy.mjs";

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

@@ -1,7 +1,8 @@
 import { execFile } from "node:child_process";
-import { access, constants } from "node:fs/promises";
 import path from "node:path";
 
+import { resolveExecutable as resolveOnPath } from "@agents-can-communicate/adapter-sdk";
+
 import { uninstallShellBootstrap } from "./shell-bootstrap.mjs";
 import { LIVE_POLICIES, livePolicyOf } from "./live-policy.mjs";
 
@@ -22,19 +23,10 @@ export const shimDirFor = stateRoot => path.join(stateRoot, "bin");
 
 // 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)) {
-    if (excluded.includes(path.resolve(directory))) continue;
-    const candidate = path.join(directory, command);
-    try {
-      await access(candidate, constants.X_OK);
-      return candidate;
-    } catch {
-      // not here; keep walking PATH
-    }
-  }
-  return null;
+// Windows adds an extension from PATHEXT; see the SDK's resolveExecutable.
+export async function resolveExecutable(command, { pathEnv = "", exclude = [], pathExt } = {}) {
+  return resolveOnPath(command, { pathEnv, exclude,
+    ...(pathExt === undefined ? {} : { pathExt }) });
 }
 
 const defaultExec = (executable, args) => new Promise((resolve, reject) => {

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

@@ -78,6 +78,20 @@ export function planInstallation({ adapters, detected, context, action = "instal
           + `if it is, wire it with --adapter ${entry.adapterId}` });
       continue;
     }
+    // An uninstall takes back what this data home installed. A client that is
+    // here but that this home has no record of was wired by another ACC data
+    // home - the operator's own, beside an isolated test home - or before this
+    // home kept records, and removing it unasked took the operator's wiring
+    // with it (#253). Naming the client still removes it.
+    if (action === "uninstall" && entry.present && recordedById.get(entry.adapterId) === undefined
+      && !askedFor.has(entry.adapterId)) {
+      // Also what a second uninstall says: by then this home has no record left.
+      skipped.push({ adapterId: entry.adapterId,
+        reason: `${entry.displayName ?? entry.adapterId} has no install record in this ACC data home, `
+          + "so ACC leaves it as it is; to remove ACC wiring another data home put there, run "
+          + `acc uninstall --adapter ${entry.adapterId}` });
+      continue;
+    }
     // An adapter can refuse itself for a reason that is nobody's fault and that
     // no file on disk shows: Antigravity CLI cannot be wired until somebody
     // picks between a machine-wide and a per-workspace hook registration. It is

package/node_modules/@agents-can-communicate/mcp-server/package.json

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

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

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

package/node_modules/@agents-can-communicate/protocol/src/config.mjs

@@ -53,8 +53,12 @@ function assertRoot(root, source) {
   if (typeof root !== "string" || root === "") {
     data("each workspace root must be a non-empty string", { source, root });
   }
-  // Absolute is one machine's layout committed to a shared repository.
-  if (root.startsWith("/") || /^[A-Za-z]:[\\/]/.test(root)) {
+  // Absolute is one machine's layout committed to a shared repository. On
+  // Windows a leading separator is rooted on the current drive, `\\host\share`
+  // reaches another machine and `D:x` is relative to another drive's current
+  // directory, so a drive letter or a leading separator is refused on every
+  // platform: a config that is harmless on POSIX travels to Windows unchanged.
+  if (/^[\\/]/.test(root) || /^[A-Za-z]:/.test(root)) {
     data("a workspace root must be relative to the config", { source, root });
   }
   // Checked on the segments rather than the string: `packages/../../escape`

package/node_modules/@agents-can-communicate/protocol/src/resources.mjs

@@ -14,6 +14,10 @@
  */
 const GLOB = "/**";
 
+// A Windows agent separates segments with a backslash. Only the path part of a
+// `file:` resource is converted; see normaliseResource.
+const slashes = value => value.replaceAll("\\", "/");
+
 function normalisePath(value) {
   const segments = [];
   for (const segment of value.split("/")) {
@@ -44,7 +48,7 @@ function normalisePath(value) {
  */
 export function assertMatchableResource(resource, fail) {
   if (typeof resource !== "string" || !resource.startsWith("file:")) return resource;
-  const rest = resource.slice("file:".length);
+  const rest = slashes(resource.slice("file:".length));
   if (rest.endsWith("/") && rest !== "/") {
     fail(`${resource} names a directory; claim ${resource}** to cover what is in it`);
   }
@@ -61,7 +65,7 @@ export function normaliseResource(resource) {
   const colon = resource.indexOf(":");
   if (colon === -1 || resource.slice(0, colon) !== "file") return resource;
 
-  const rest = resource.slice(colon + 1);
+  const rest = slashes(resource.slice(colon + 1));
   const glob = rest.endsWith(GLOB);
   const body = glob ? rest.slice(0, -GLOB.length) : rest;
   // An absolute path keeps its leading slash: it names a different thing from

package/node_modules/@agents-can-communicate/storage-filesystem/package.json

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

package/node_modules/@agents-can-communicate/storage-filesystem/src/active-journal.mjs

@@ -4,7 +4,7 @@ import path from "node:path";
 
 import { AccError, EXIT, assertPortableId } from "@agents-can-communicate/protocol";
 
-import { encode, publishAtomic } from "./atomic-json.mjs";
+import { encode, nameCommittedLater, publishAtomic } from "./atomic-json.mjs";
 import { withRegularNoFollow } from "./safe-file.mjs";
 
 const ACTIVE_JOURNAL_VERSION = 2;
@@ -181,7 +181,10 @@ export async function initialiseActiveJournal(paths, options) {
   const current = await readCurrent(paths, options.root);
   if (current !== null) return current.record;
   try {
-    await publishAtomic(activeJournalPath(paths, 0), encodeAuthority(genesis()), options);
+    // The first record any write publishes commits this name on Windows; a
+    // crash before it leaves no pointer, which the next open initialises.
+    await publishAtomic(activeJournalPath(paths, 0), encodeAuthority(genesis()),
+      { ...options, durability: nameCommittedLater(options.platform) });
   } catch (error) {
     if (error.code !== EXIT.CONFLICT) throw error;
   }