agents-can-communicate 0.10.1 → 0.10.2

package/docs/ARCHITECTURE.md

@@ -272,8 +272,12 @@ running. A binding that names no client process is judged by its session record
 exited, or, with no process recorded, when ACC's presence rule calls the session offline -
 closed, or 30 minutes without a heartbeat. A live recorded process, or a record that cannot be
 read, keeps it a hold. A client that wakes later runs its next hook through the launcher on
-the active generation. For a binding that names its client, presence TTL, `acc finish`, and
-delivery off do not prove native lifecycle end. Normal background updates never
+the active generation. A binding that names its client stops holding when that process exits,
+or when the process that now has its pid started after the binding was last written, since a
+client runs when it writes its binding (#276); a start time that cannot be read decides
+nothing. Otherwise presence TTL, `acc finish`, and delivery off do not prove native lifecycle
+end. A pending release that cannot activate is replaced by a newer one when `acc update` runs
+or an automatic check is due (#277). Normal background updates never
 restart a vendor daemon. An explicitly approved maintenance job can do so through the
 adapter lifecycle port: it waits for idle work, validates exact process identity, stops
 the service under the admission fence, refreshes integrations, and restores and verifies

package/docs/UPGRADING.md

@@ -57,6 +57,19 @@ closed. 0.10.1 judges such a binding by its session record and removes it while
 the update, so the update from 0.9.x finishes once no 0.9.x session runs. From 0.10.0, 0.10.1
 keeps the store contract, so it activates without waiting for open sessions.
 
+If `acc update` keeps retrying a pending 0.10.0 or 0.10.1 and names processes that are not your
+clients, or `unknown client pid`, clear the pending release and update again:
+
+<!-- test:illustration needs an installed ACC with a release pending; a fresh sandbox has neither -->
+```bash
+acc update --pin none
+acc update
+```
+
+`--pin none` keeps following stable releases and drops a pending release that is not pinned.
+From 0.10.2, the update does this by itself: a pending release that cannot activate is replaced
+by a newer one, and a binding whose pid another program now has no longer holds the update.
+
 ## From 0.8.x
 
 Update as usual:

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/adapter-antigravity",
-  "version": "0.10.1",
+  "version": "0.10.2",
   "private": true,
   "type": "module",
   "exports": {

package/node_modules/@agents-can-communicate/adapter-antigravity/plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "acc",
-  "version": "0.10.1",
+  "version": "0.10.2",
   "description": "Coordinate this Antigravity CLI session with other AI agent sessions working in the same workspace."
 }

package/node_modules/@agents-can-communicate/adapter-claude-code/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/adapter-claude-code",
-  "version": "0.10.1",
+  "version": "0.10.2",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/adapter-codex",
-  "version": "0.10.1",
+  "version": "0.10.2",
   "private": true,
   "type": "module",
   "exports": {

package/node_modules/@agents-can-communicate/adapter-gemini-cli/extension/gemini-extension.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-can-communicate",
-  "version": "0.10.1",
+  "version": "0.10.2",
   "description": "Coordinate this Gemini CLI session with other AI agent sessions working in the same workspace.",
   "contextFileName": "skills/acc/SKILL.md"
 }

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/adapter-gemini-cli",
-  "version": "0.10.1",
+  "version": "0.10.2",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/adapter-grok",
-  "version": "0.10.1",
+  "version": "0.10.2",
   "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.10.1",
+  "version": "0.10.2",
   "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.10.1",
+  "version": "0.10.2",
   "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.10.1",
+  "version": "0.10.2",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -1,10 +1,13 @@
+import { execFile } from "node:child_process";
 import { createHash } from "node:crypto";
 // Kept above 300 lines because activation and generation retirement must use
 // the same validated runtime/native hold definitions under the admission mutex.
 // Splitting their safety rules risks disagreeing about which users are live.
-import { readdir, rm } from "node:fs/promises";
+import { readdir, rm, stat } from "node:fs/promises";
 import path from "node:path";
 import { pathToFileURL } from "node:url";
+import { promisify } from "node:util";
+import { readWindowsProcess } from "@agents-can-communicate/adapter-sdk";
 import { classifySessionPresence } from "@agents-can-communicate/core";
 import { assertPortableId } from "@agents-can-communicate/protocol";
 import { readSessionRecord, withWriterMutex } from "@agents-can-communicate/storage-filesystem";
@@ -49,6 +52,46 @@ async function isMcpContinuity(record, name, workspaceRoot, workspaceId) {
 const clientPidOf = record => record?.schemaVersion === 1 && Number.isSafeInteger(record.clientPid)
   && record.clientPid > 0 ? record.clientPid : null;
 
+const execFileAsync = promisify(execFile);
+
+/** When a process started, in milliseconds since the epoch; null when it cannot be read. */
+export async function processStartedAt(pid, { platform = process.platform, run = execFileAsync } = {}) {
+  try {
+    if (platform === "win32") {
+      const found = await readWindowsProcess(pid, { timeoutMs: 5_000 });
+      if (found?.pid !== pid || typeof found.start !== "string" || !/^\d+$/.test(found.start)) return null;
+      // A FILETIME: 100-nanosecond intervals since 1601-01-01 UTC.
+      return Number(BigInt(found.start) / 10_000n) - 11_644_473_600_000;
+    }
+    const { stdout } = await run("/bin/ps", ["-p", String(pid), "-o", "lstart="],
+      { timeout: 2_000, env: { ...process.env, LC_ALL: "C" } });
+    const started = Date.parse(stdout.trim());
+    return Number.isFinite(started) ? started : null;
+  } catch { return null; }
+}
+
+/** A client runs when it writes its binding, so a process that started after
+ * the binding was last written is not that client: the operating system gave
+ * its pid to another program. On 2026-10-06 chrome-devtools-mcp and two IntelliJ
+ * helpers held three such pids and kept 0.10.1 pending (#276). `ps` counts whole
+ * seconds and a filesystem may too; a second of slack keeps a client's own
+ * process from reading as another. A start time that cannot be read decides
+ * nothing. */
+async function pidReused(pid, file, startedAt) {
+  const [started, written] = await Promise.all([startedAt(pid),
+    stat(file).then(info => info.mtimeMs, () => null)]);
+  return started !== null && written !== null && started > written + 1_000;
+}
+
+// One start-time reading per pid for one pass: a vendor service can hold several bindings.
+const perPass = startedAt => {
+  const seen = new Map();
+  return pid => {
+    if (!seen.has(pid)) seen.set(pid, Promise.resolve().then(() => startedAt(pid)).catch(() => null));
+    return seen.get(pid);
+  };
+};
+
 /** A binding that names no client process cannot be judged by its own facts;
  * its session record can. It is stale when the record is gone, when the record
  * names a process that has exited, or, with no process recorded, when ACC's own
@@ -57,7 +100,7 @@ const clientPidOf = record => record?.schemaVersion === 1 && Number.isSafeIntege
  * process, or a record or store that cannot be read, keeps the binding a hold.
  * On 2026-10-06 the maintainer's 0.10.0 waited behind 32 such bindings from
  * 0.5.10 to 0.9.0 that no client could clear (#273). */
-async function staleWithoutPid(workspaceRoot, workspaceId, record, pidIsAlive) {
+async function staleWithoutPid(workspaceRoot, workspaceId, record, pidIsAlive, file, startedAt) {
   if (record?.schemaVersion !== 1) return false;
   let session;
   try {
@@ -65,15 +108,19 @@ async function staleWithoutPid(workspaceRoot, workspaceId, record, pidIsAlive) {
       sessionId: record.accSessionId, allowLegacyIdentity: true });
   } catch { return false; }
   if (session === null) return true;
-  if (Number.isSafeInteger(session.pid) && session.pid > 0) return confirmedDead(session.pid, pidIsAlive);
+  if (Number.isSafeInteger(session.pid) && session.pid > 0) {
+    return await confirmedDead(session.pid, pidIsAlive) || pidReused(session.pid, file, startedAt);
+  }
   // No process to ask, so the probe is never called.
   return classifySessionPresence(session, new Date().toISOString(), () => true) === "offline";
 }
 
 /** Native bindings outlive finish/TTL; MCP process lifetime is covered by its runtime lease. */
-export async function listNativeHolds(root, { pidIsAlive = defaultPidIsAlive, strict = false } = {}) {
+export async function listNativeHolds(root, { pidIsAlive = defaultPidIsAlive, strict = false,
+  startedAt = processStartedAt } = {}) {
   const workspaces = path.join(path.dirname(await canonicalManagerRoot(root)), "workspaces");
   if (!await managedDirectory(workspaces)) return [];
+  const started = perPass(startedAt);
   const holds = [];
   for (const entry of await readdir(workspaces, { withFileTypes: true })) {
     if (!entry.isDirectory()) {
@@ -87,15 +134,17 @@ export async function listNativeHolds(root, { pidIsAlive = defaultPidIsAlive, st
     if (!await managedDirectory(bindings)) continue;
     for (const name of await readdir(bindings)) {
       if (!name.endsWith(".json")) continue;
-      const record = await readManagedJson(path.join(bindings, name)).catch(error => {
+      const file = path.join(bindings, name);
+      const record = await readManagedJson(file).catch(error => {
         if (strict) throw error;
         return null;
       });
       if (record === undefined) continue; // Concurrent lifecycle removal, before fencing.
       if (await isMcpContinuity(record, name, path.dirname(bindings), entry.name)) continue;
       const pid = clientPidOf(record);
-      if (pid !== null && await confirmedDead(pid, pidIsAlive)) continue;
-      if (pid === null && await staleWithoutPid(path.dirname(bindings), entry.name, record, pidIsAlive)) continue;
+      if (pid !== null && (await confirmedDead(pid, pidIsAlive) || await pidReused(pid, file, started))) continue;
+      if (pid === null && await staleWithoutPid(path.dirname(bindings), entry.name, record, pidIsAlive,
+        file, started)) continue;
       holds.push({ kind: "native", pid, reason: pid === null ? "unknown_client_pid" : "client_running",
         storeVersion: Number.isSafeInteger(record?.storeVersion) ? record.storeVersion : null });
     }
@@ -109,17 +158,21 @@ const LIFECYCLE_LOCK_MS = 2_000;
 const lifecycleLocks = (workspaceRoot, harnessSessionId) => ({ locks: path.join(workspaceRoot,
   "lifecycle-locks", createHash("sha256").update(String(harnessSessionId)).digest("hex")) });
 
-/** Remove the bindings without a client pid that listNativeHolds no longer
- * counts. An older generation activates its successor with its own rule, which
- * counts every one of them as a live client; it loads the pending generation's
- * refresh before it lists blockers, so that refresh calls this (#273). Each one
- * is judged again and removed under its session's lifecycle lock, so a hook that
- * renews it is either seen or comes after (AI review of #274); a lock that stays
- * busy leaves the binding as it is. */
-export async function sweepStaleBindings(root, { pidIsAlive = defaultPidIsAlive } = {}) {
+/** Remove the bindings that listNativeHolds no longer counts and an older
+ * generation still does: those without a client pid that are stale (#273), and
+ * those whose pid was given to another program (#276). An older generation
+ * activates its successor with its own rule, and loads the pending generation's
+ * refresh before it lists blockers, so that refresh calls this. A binding whose
+ * pid is merely dead holds nothing for either and stays, as the record a resumed
+ * conversation finds. Each one is judged again and removed under its session's
+ * lifecycle lock, so a hook that renews it is either seen or comes after (AI
+ * review of #274); a lock that stays busy leaves the binding as it is. */
+export async function sweepStaleBindings(root, { pidIsAlive = defaultPidIsAlive,
+  startedAt = processStartedAt } = {}) {
   const workspaces = path.join(path.dirname(await canonicalManagerRoot(root)), "workspaces");
   if (!await managedDirectory(workspaces)) return 0;
   const clock = { now: () => new Date().toISOString() };
+  const started = perPass(startedAt);
   let removed = 0;
   for (const entry of await readdir(workspaces, { withFileTypes: true })) {
     if (!entry.isDirectory()) continue;
@@ -130,10 +183,13 @@ export async function sweepStaleBindings(root, { pidIsAlive = defaultPidIsAlive
     for (const name of await readdir(bindings)) {
       if (!name.endsWith(".json")) continue;
       const file = path.join(bindings, name);
-      const stale = async record => record !== undefined && record !== null
-        && clientPidOf(record) === null && typeof record.harnessSessionId === "string"
-        && !await isMcpContinuity(record, name, workspaceRoot, entry.name)
-        && staleWithoutPid(workspaceRoot, entry.name, record, pidIsAlive);
+      const stale = async record => {
+        if (record === undefined || record === null || typeof record.harnessSessionId !== "string"
+          || await isMcpContinuity(record, name, workspaceRoot, entry.name)) return false;
+        const pid = clientPidOf(record);
+        if (pid !== null) return !await confirmedDead(pid, pidIsAlive) && pidReused(pid, file, started);
+        return staleWithoutPid(workspaceRoot, entry.name, record, pidIsAlive, file, started);
+      };
       const judged = await readManagedJson(file).catch(() => undefined);
       if (!await stale(judged)) continue;
       const gone = await withWriterMutex(lifecycleLocks(workspaceRoot, judged.harnessSessionId),
@@ -165,9 +221,10 @@ export const blocksActivation = (hold, incomingStoreVersion) =>
  * generation's, or when either side declares none.
  */
 export async function listActivationBlockers(root, { pidIsAlive = defaultPidIsAlive,
-  ignorePid = null, incomingStoreVersion = null, strictNative = false } = {}) {
+  ignorePid = null, incomingStoreVersion = null, strictNative = false, startedAt } = {}) {
   const leases = (await listRuntimeHolds(root, { pidIsAlive })).filter(lease => lease.pid !== ignorePid);
-  const native = await listNativeHolds(root, { pidIsAlive, strict: strictNative });
+  const native = await listNativeHolds(root, { pidIsAlive, strict: strictNative,
+    ...(startedAt === undefined ? {} : { startedAt }) });
   const holds = [
     ...leases.map(({ pid, kind, runtime }) => ({ pid, kind, nativeBindings: 0,
       storeVersion: runtime?.storeVersion ?? null })),
@@ -364,7 +421,7 @@ const recipe = c => JSON.stringify([c.active, c.pending, c.home, c.targets, c.au
 
 /** Detection is outside the fence; every integration write and commit stays inside it. */
 export async function activatePending(root, { prepare = prepareCandidate, env = process.env,
-  pidIsAlive = defaultPidIsAlive, ignorePid = null, beforeActivation = null } = {}) {
+  pidIsAlive = defaultPidIsAlive, ignorePid = null, beforeActivation = null, startedAt } = {}) {
   root = await canonicalManagerRoot(root);
   const before = await readControl(root);
   if (!before?.pending) return { activated: false, reason: "no_pending_update" };
@@ -374,7 +431,7 @@ export async function activatePending(root, { prepare = prepareCandidate, env =
     const current = await readControl(root);
     if (!current || recipe(current) !== recipe(before)) return { activated: false, reason: "state_changed" };
     if (beforeActivation) await beforeActivation(current);
-    const blockers = await listActivationBlockers(root, { pidIsAlive, ignorePid,
+    const blockers = await listActivationBlockers(root, { pidIsAlive, ignorePid, startedAt,
       incomingStoreVersion: current.pending.storeVersion });
     if (blockers.length) {
       const notice = activationBlockerNotice(current.pending.version, blockers);

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

@@ -32,8 +32,18 @@ export async function performUpdate(root, { force = false, check = false, env =
   }
   if (!force && !check && !initial.auto) return { ...data, checked: false, reason: "auto_off" };
   // Recovery is local; the hard no-network override must not strand a partial refresh.
+  let baseline = initial.active.version;
+  let attempt = null;
   if (initial.pending && !check && (force || !networkDisabled(env))) {
-    return { ...data, ...await activate(root, { env, ignorePid }), checked: false };
+    attempt = await activate(root, { env, ignorePid });
+    // A pending release that cannot activate kept every later one out: on
+    // 2026-10-06 0.10.0 stayed pending behind stale bindings, and the 0.10.1
+    // that fixed them reached the machine only after its pending release was
+    // cleared by hand (#277). Once a check is due, or when asked, a newer
+    // release is staged in its place.
+    if (attempt.activated || attempt.reason !== "processes_active" || networkDisabled(env)
+      || !force && !checkDue(initial)) return { ...data, ...attempt, checked: false };
+    baseline = initial.pending.version;
   }
   if (networkDisabled(env)) return { ...data, checked: false, reason: "network_disabled" };
   if (!force && !check && !checkDue(initial)) return { ...data, checked: false, reason: "not_due" };
@@ -44,7 +54,9 @@ export async function performUpdate(root, { force = false, check = false, env =
   const release = await discover({ pin: initial.pin, env });
   const newer = newerVersion(release.version, initial.active.version);
   const checked = { ...data, checked: true, latest: release.version, newer };
-  if (check || !newer) return checked;
+  // Nothing newer than a blocked pending release: report the activation that
+  // waits, as before - the caller asks to restart a client service from it.
+  if (check || !newerVersion(release.version, baseline)) return attempt === null ? checked : { ...checked, ...attempt };
   const generation = await download(root, release, { env });
   // generation.hold has protected this candidate since it was staged;
   // release it once this publish attempt resolves either way - published,

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/core",
-  "version": "0.10.1",
+  "version": "0.10.2",
   "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.10.1",
+  "version": "0.10.2",
   "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.10.1",
+  "version": "0.10.2",
   "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.10.1",
+  "version": "0.10.2",
   "private": true,
   "type": "module",
   "exports": {

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

@@ -1,6 +1,6 @@
 {
   "name": "@agents-can-communicate/mcp-server",
-  "version": "0.10.1",
+  "version": "0.10.2",
   "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.10.1",
+  "version": "0.10.2",
   "private": true,
   "type": "module",
   "exports": {

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

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agents-can-communicate",
-  "version": "0.10.1",
+  "version": "0.10.2",
   "accManagedUpdateProtocol": 2,
   "accStoreVersion": 7,
   "type": "module",