@botbuddy/cli 1.64.16 → 1.64.18

package/daemon-release/darwin-arm64.json

@@ -1,7 +1,7 @@
 {
-  "release_version": "1.64.16",
-  "source_commit": "6690f94e4c3d385159ca315713a6eab3560289fb",
-  "source_sha256": "81838b2e5024a22f62c4b55a75c3113c26cfe88f0047f0048f28f5800d0693d3",
+  "release_version": "1.64.18",
+  "source_commit": "ce75c0db8999addc150c16458ebeace234a11ac7",
+  "source_sha256": "524adf0ce3779f1b458c5aaea9e6af52269423cecb0abec9a4fbf73b7da0f4ad",
   "target": "darwin-arm64",
-  "sha256": "9ca9db33cdee03687c26d5e162f4d936d44b7c1c23028c78566a61b90f7c40ad"
+  "sha256": "4f30f4a1f5be06733dc65e8930a13f66b5cd766cb7808b34a60ae63f9b1d8f25"
 }

package/daemon-release/linux-x64.json

@@ -1,7 +1,7 @@
 {
-  "release_version": "1.64.16",
-  "source_commit": "6690f94e4c3d385159ca315713a6eab3560289fb",
-  "source_sha256": "81838b2e5024a22f62c4b55a75c3113c26cfe88f0047f0048f28f5800d0693d3",
+  "release_version": "1.64.18",
+  "source_commit": "ce75c0db8999addc150c16458ebeace234a11ac7",
+  "source_sha256": "524adf0ce3779f1b458c5aaea9e6af52269423cecb0abec9a4fbf73b7da0f4ad",
   "target": "linux-x64",
-  "sha256": "b1a73bbd5bc7d78a13a3ec6f547436cc780163687bb5162e230d5796291e7689"
+  "sha256": "5b07c264400be4a1790ddb3f8a0b0880465deff8eaccbb0cf18a7e734385326d"
 }

package/daemon-release/manifest.json

@@ -1,21 +1,21 @@
 {
   "schema_version": 1,
-  "release_version": "1.64.16",
-  "source_commit": "6690f94e4c3d385159ca315713a6eab3560289fb",
-  "source_sha256": "81838b2e5024a22f62c4b55a75c3113c26cfe88f0047f0048f28f5800d0693d3",
+  "release_version": "1.64.18",
+  "source_commit": "ce75c0db8999addc150c16458ebeace234a11ac7",
+  "source_sha256": "524adf0ce3779f1b458c5aaea9e6af52269423cecb0abec9a4fbf73b7da0f4ad",
   "targets": {
     "darwin-arm64": {
       "goos": "darwin",
       "goarch": "arm64",
       "binary": "daemon/bin/darwin-arm64/botbuddy-daemon",
-      "sha256": "9ca9db33cdee03687c26d5e162f4d936d44b7c1c23028c78566a61b90f7c40ad",
+      "sha256": "4f30f4a1f5be06733dc65e8930a13f66b5cd766cb7808b34a60ae63f9b1d8f25",
       "mode": "0755"
     },
     "linux-x64": {
       "goos": "linux",
       "goarch": "amd64",
       "binary": "daemon/bin/linux-x64/botbuddy-daemon",
-      "sha256": "b1a73bbd5bc7d78a13a3ec6f547436cc780163687bb5162e230d5796291e7689",
+      "sha256": "5b07c264400be4a1790ddb3f8a0b0880465deff8eaccbb0cf18a7e734385326d",
       "mode": "0755"
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@botbuddy/cli",
-  "version": "1.64.16",
+  "version": "1.64.18",
   "description": "BotBuddy \u2014 Swarm coordination CLI for multi-agent workflows",
   "type": "module",
   "bin": {

package/src/commands.mjs

@@ -147,7 +147,7 @@ export async function run(argv, {
     case "wait": return runWait(args);
     case "pw": return runPw(args);
     // BOT-2084: the human-installed staging session pool broker.
-    case "staging-pool": return (await import("./staging-pool/cli.mjs")).runStagingPool(args);
+    case "staging-pool": return (await import("./staging-pool/cli.mjs")).runStagingPool(args, { cliVersion: VERSION });
     case "mcp": return cmdMcp(args);
     case "resources": return callTool("list_resources");
     case "agents": return callTool("list_agents");

package/src/stack-run-outcome.mjs

@@ -185,6 +185,9 @@ export function buildStackRunOutcomePayload({ fields = {}, exitCode, runId = ran
   const signal = pick(fields.stop_signal?.signal, SIGNAL_RE);
   // BOT-2880: sent only when present, because an older server refuses an unknown key.
   const callbackAuthorizationReason = pick(fields.callback_authorization_reason, AUTHORIZATION_REASON_RE);
+  const failureMechanism = code === "REQUESTER_ORIGIN_DIGEST_UNAVAILABLE" &&
+      ["origin_config_missing", "origin_digest_missing"].includes(fields.failure_mechanism)
+    ? fields.failure_mechanism : null;
   return {
     run_id: runId,
     lease_id: validStackLeaseId(fields.lease_id),
@@ -208,6 +211,7 @@ export function buildStackRunOutcomePayload({ fields = {}, exitCode, runId = ran
       signal_parent: pick(fields.stop_signal.parent, TOKEN_RE),
     } : {}),
     ...(callbackAuthorizationReason ? { callback_authorization_reason: callbackAuthorizationReason } : {}),
+    ...(failureMechanism ? { failure_mechanism: failureMechanism } : {}),
   };
 }
 
@@ -236,7 +240,19 @@ export async function reportStackRunOutcome({ fields, exitCode, runId, opts, env
     timer = setTimeout(() => { ac.abort(); resolve(TIMED_OUT); }, timeoutMs);
   });
   try {
-    const call = Promise.resolve().then(() => channel.callTool(STACK_RUN_OUTCOME_TOOL, payload, { auth: channel.auth, signal: ac.signal }));
+    const call = Promise.resolve().then(async () => {
+      const first = await channel.callTool(STACK_RUN_OUTCOME_TOOL, payload, { auth: channel.auth, signal: ac.signal });
+      // Older servers reject unknown keys before writing. Retry only that exact,
+      // explicit rejection with the same run id; never retry an uncertain send.
+      if (!ac.signal.aborted && payload.failure_mechanism && first?.ok && first?.isError &&
+          first?.data?.code === "INVALID_STACK_RUN_OUTCOME" &&
+          typeof first?.data?.message === "string" &&
+          first.data.message.startsWith("unknown key 'failure_mechanism'")) {
+        const { failure_mechanism: _omitted, ...legacyPayload } = payload;
+        return await channel.callTool(STACK_RUN_OUTCOME_TOOL, legacyPayload, { auth: channel.auth, signal: ac.signal });
+      }
+      return first;
+    });
     const result = await Promise.race([call.catch(() => null), timeout]);
     if (result === TIMED_OUT) return { sent: false, reason: "timeout", payload };
     const capture = result?.data?.feedback_capture;

package/src/stack.mjs

@@ -4250,7 +4250,7 @@ async function runStackLifecycleOnce(opts, childArgv, adapters, incidentBox) {
       let hasDeclaration = false;
       try { hasDeclaration = existsSync(declaration) && lstatSync(declaration).isFile(); } catch { hasDeclaration = false; }
       if (remoteVariant && !originConfigPath) {
-        const error = new Error("the requester-origin config variant has no materialized config to replace"); error.code = "REQUESTER_ORIGIN_DIGEST_UNAVAILABLE"; throw error;
+        const error = new Error("the requester-origin config variant has no materialized config to replace"); error.code = "REQUESTER_ORIGIN_DIGEST_UNAVAILABLE"; error.failureMechanism = "origin_config_missing"; throw error;
       }
       return buildBundle(stackDirFor(execution), {
         ...(remoteVariant ? { readFile: (abs, ...rest) => abs === originConfigPath ? Buffer.from(execution.originConfigText, "utf8") : readFileSync(abs, ...rest) } : {}),
@@ -4288,7 +4288,8 @@ async function runStackLifecycleOnce(opts, childArgv, adapters, incidentBox) {
         // hide it — and it happens before any lease exists.
         if (executionRequest === "remote" || bundleInclude.length) {
           const fixable = typeof error?.code === "string" && error.code.startsWith("BUNDLE_");
-          return { exitCode: fixable ? EXIT.INVALID : EXIT.INTERNAL, outcome: "error", code: error?.code ?? "BUNDLE_FAILED", error: message };
+          return { exitCode: fixable ? EXIT.INVALID : EXIT.INTERNAL, outcome: "error", code: error?.code ?? "BUNDLE_FAILED", error: message,
+            ...(error?.code === "REQUESTER_ORIGIN_DIGEST_UNAVAILABLE" && error?.failureMechanism === "origin_config_missing" ? { failureMechanism: error.failureMechanism } : {}) };
         }
         // Codex #1077 P2: without a digest, `auto` could still pick a remote host and be
         // refused BUNDLE_REQUIRED instead of queueing here, so ask for this machine.
@@ -4346,7 +4347,7 @@ async function runStackLifecycleOnce(opts, childArgv, adapters, incidentBox) {
     let renewIdentifiedRequest = null;
     if (execution.admissionRequestId) {
       if (!stackDigest || !bundle?.sha256) {
-        return { exitCode: EXIT.INTERNAL, outcome: "error", code: "REQUESTER_ORIGIN_DIGEST_UNAVAILABLE", error: "the requester-origin bundle digest could not be computed; no lease was requested" };
+        return { exitCode: EXIT.INTERNAL, outcome: "error", code: "REQUESTER_ORIGIN_DIGEST_UNAVAILABLE", failureMechanism: "origin_digest_missing", error: "the requester-origin bundle digest could not be computed; no lease was requested" };
       }
       leaseArgs.request_id = execution.admissionRequestId;
       // Durable request-to-context association before any request can commit (recovery key).
@@ -5323,6 +5324,8 @@ export function runReceiptFields(result) {
     ...(result.callbackCause ? { callback_cause: result.callbackCause } : {}),
     // BOT-2880: which check refused a CALLBACK_AUTHORIZATION_LOST (a bounded token, never a value).
     ...(result.callbackAuthorizationReason ? { callback_authorization_reason: result.callbackAuthorizationReason } : {}),
+    ...(result.code === "REQUESTER_ORIGIN_DIGEST_UNAVAILABLE" && ["origin_config_missing", "origin_digest_missing"].includes(result.failureMechanism)
+      ? { failure_mechanism: result.failureMechanism } : {}),
     // BOT-2957: the control-plane gaps this run's callback route rode through (never on a run that had none).
     ...(result.callbackOutage ? { callback_outage: result.callbackOutage } : {}),
     // BOT-2780: the reserved requester origin generated auth links name (never a credential).

package/src/staging-pool/cli.mjs

@@ -398,6 +398,26 @@ export function upgradeNotice(ctx) {
   return { upgrade: { reason: "installed_before_registry", message: "This pool was installed from a repository checkout; re-install it from the BotBuddy control plane (keeps counts and interval).", next: installCommandFor(ctx.tenant) } };
 }
 
+// BOT-3016: the launchd job runs a pinned runtime copy, not this CLI. Status
+// names both versions and, when they differ on a control-plane pool, the
+// agent-safe refresh (bb update runs it too). cliVersion is null inside the
+// bundled job copy, which has no package.json to read.
+export function runtimeNotice(ctx, cliVersion) {
+  if (!ctx?.installed || ctx.installed.error) return {};
+  const runtimeVersion = ctx.installed.runtime?.version ?? null;
+  const versions = { runtimeVersion, ...(cliVersion ? { cliVersion } : {}) };
+  if (!cliVersion || runtimeVersion === cliVersion || ctx.installed.source !== "control-plane" || !ctx.tenant || !ctx.poolId) return versions;
+  const runs = runtimeVersion ? `runs v${runtimeVersion}` : "runs an untracked runtime copy";
+  return {
+    ...versions,
+    runtimeBehind: {
+      reason: "runtime_behind",
+      message: `The pool job ${runs}, but this CLI is v${cliVersion}. bb update refreshes it; so does the next command.`,
+      next: `bb staging-pool refresh-runtime --tenant ${shellWord(String(ctx.tenant))} --pool ${shellWord(String(ctx.poolId))}`,
+    },
+  };
+}
+
 export async function runStagingPool(argv, deps = {}) {
   const {
     env = process.env,
@@ -415,6 +435,7 @@ export async function runStagingPool(argv, deps = {}) {
     nodeBin = process.execPath,
     sleep = (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
     readSecretFile = readFileSync,
+    cliVersion = null,
   } = deps;
 
   const redactor = createRedactor();
@@ -599,10 +620,10 @@ export async function runStagingPool(argv, deps = {}) {
         const entry = options.persona ? findPersona(ctx.poolBinding, options.persona) : null;
         if (options.persona && !entry) assertPersonaAllowed(target, options.persona);
         const health = await assessHealth({ ctx, pool, now, exec, uid, requestedPersona: entry?.email });
-        emit({ command: "status", check: true, ...health, ...upgradeNotice(ctx) });
+        emit({ command: "status", check: true, ...health, ...upgradeNotice(ctx), ...runtimeNotice(ctx, cliVersion) });
         return health.ok ? 0 : 5;
       }
-      emit({ ok: true, command: "status", ...(await pool.status()), ...upgradeNotice(ctx) });
+      emit({ ok: true, command: "status", ...(await pool.status()), ...upgradeNotice(ctx), ...runtimeNotice(ctx, cliVersion) });
       return 0;
     },
 

package/src/staging-pool/help.mjs

@@ -96,14 +96,16 @@ ANYONE (agents too) — existing runtime maintenance, never sign-in
       and this published CLI package. Preserves credentials, sessions, counts,
       interval and plist. The existing launchd job refills on its next tick.
       No caller path or runtime content is accepted; no sign-in is performed.
+      bb update runs it for every installed pool after a confirmed upgrade.
 
 HUMAN ONLY (Jono, from Terminal.app or iTerm) — refused inside a Claude or Codex session
   These sign in with the persona password or change the standing sessions.
   install --tenant <slug> [--pool <pool_id>] --botbuddy-bin <absolute path> [--interval <seconds>]
       Reads the tenant's registered pool from the BotBuddy control plane, copies
       the job to the pool home, writes its config and loads the launchd job. Run
-      it from any directory. Re-run after upgrading @botbuddy/cli; it keeps the
-      counts and interval. --pool is needed only when the tenant has several.
+      it from any directory. bb update refreshes the job's runtime, so re-run
+      install only when status or bb update names it; it keeps the counts and
+      interval. --pool is needed only when the tenant has several.
       e.g. bb staging-pool install --tenant botbuddy --botbuddy-bin "$(command -v botbuddy)"
   tick [--pool <pool_id>] [--home <pool home>]
       One refresh and refill pass now (what the job runs).

package/src/update-check.mjs

@@ -11,14 +11,23 @@
 // `cmdUpdate` deliberately does NOT update in-process (BOT-1499: a self-update
 // that replaces its own running files can kill itself mid-install). It hands
 // off to a detached, unref'd `npm install -g` and exits 0.
+//
+// BOT-3016: an installed staging session pool is a standing launchd job that
+// runs a pinned copy of the CLI, so npm alone leaves it on old code. After a
+// confirmed update, `cmdUpdate` refreshes each control-plane pool with the NEW
+// package's agent-safe `staging-pool refresh-runtime` (BOT-2673), which derives
+// its runtime from its own package path — hence a child of the new binary, not
+// this process. A refusal is reported once and never fails the update.
 
-import { mkdir, readFile, writeFile } from "node:fs/promises";
+import { mkdir, readFile, readdir, writeFile } from "node:fs/promises";
 import { readFileSync } from "node:fs";
-import { spawn, spawnSync } from "node:child_process";
+import { execFile, spawn, spawnSync } from "node:child_process";
 import { homedir } from "node:os";
 import { dirname, join } from "node:path";
+import { promisify } from "node:util";
 
 import { VERSION } from "./version.mjs";
+import { installLine } from "./staging-pool/errors.mjs";
 
 export const UPDATE_CHECK_INTERVAL_MS = 24 * 60 * 60 * 1000;
 export const NPM_LATEST_URL = "https://registry.npmjs.org/@botbuddy/cli/latest";
@@ -118,11 +127,16 @@ export async function maybeWarnStale({
   }
 }
 
-export function readInstalledVersion({ npmBin = "npm", shellOpt = {}, probeImpl = spawnSync, readPackage = readFileSync } = {}) {
+export function readNpmGlobalRoot({ npmBin = "npm", shellOpt = {}, probeImpl = spawnSync } = {}) {
   const root = probeImpl(npmBin, ["root", "-g"], { encoding: "utf8", ...shellOpt });
   if (root?.error || root?.status !== 0) throw new Error(`npm global root lookup failed for ${npmBin}`);
   const directory = String(root?.stdout ?? "").trim();
   if (!directory) throw new Error("npm global root lookup returned no directory");
+  return directory;
+}
+
+export function readInstalledVersion({ npmBin = "npm", shellOpt = {}, probeImpl = spawnSync, readPackage = readFileSync } = {}) {
+  const directory = readNpmGlobalRoot({ npmBin, shellOpt, probeImpl });
   const packageJson = JSON.parse(readPackage(join(directory, "@botbuddy", "cli", "package.json"), "utf8"));
   if (typeof packageJson?.version !== "string" || !parseSemver(packageJson.version)) throw new Error("installed @botbuddy/cli package has no valid version");
   return packageJson.version;
@@ -130,7 +144,7 @@ export function readInstalledVersion({ npmBin = "npm", shellOpt = {}, probeImpl
 
 // `botbuddy update` waits for npm because the terminal result, rather than the
 // child-process launch, is the only trustworthy confirmation an update worked.
-export function cmdUpdate({ version = VERSION, spawnImpl = spawn, probeImpl = spawnSync, readInstalledVersion: installedVersion = readInstalledVersion, log = (line) => console.log(line), platform = process.platform, stderr = process.stderr } = {}) {
+export function cmdUpdate({ version = VERSION, spawnImpl = spawn, probeImpl = spawnSync, readInstalledVersion: installedVersion = readInstalledVersion, refreshPools = refreshPoolsFromNewPackage, log = (line) => console.log(line), platform = process.platform, stderr = process.stderr } = {}) {
   // BOT-1566 (Codex P1/P2): on Windows npm is the `npm.cmd` shim, and Node
   // cannot spawn a .cmd file shell-free (docs) — run it through a shell on
   // win32 (args are all static constants, so no injection surface) and select
@@ -179,14 +193,114 @@ export function cmdUpdate({ version = VERSION, spawnImpl = spawn, probeImpl = sp
         resolve(1);
         return;
       }
+      let installed;
       try {
-        const installed = installedVersion({ npmBin, shellOpt });
-        log(`✓ Updated to v${installed}`);
-        resolve(0);
+        installed = installedVersion({ npmBin, shellOpt });
       } catch (error) {
         try { stderr.write(`botbuddy update: npm completed but could not verify the installed version (${error?.message ?? error})\n`); } catch { /* ignore */ }
         resolve(1);
+        return;
       }
+      log(`✓ Updated to v${installed}`);
+      // BOT-3016: the update succeeded; a pool refresh problem is reported, never an exit code.
+      Promise.resolve()
+        .then(() => refreshPools({ installedVersion: installed, npmBin, shellOpt, probeImpl, log, stderr }))
+        .catch((error) => {
+          try { stderr.write(`botbuddy update: the installed staging pools were not refreshed (${error?.message ?? error}); run bb staging-pool status\n`); } catch { /* ignore */ }
+        })
+        .finally(() => resolve(0));
     });
   });
 }
+
+// ─── BOT-3016: refresh installed staging-pool runtimes after an update ───────
+
+export const REFRESH_TIMEOUT_MS = 120_000;
+const HUMAN_NEXT = "human, from Terminal.app or iTerm";
+
+export function stagingPoolsRoot(home = homedir()) {
+  return join(home, ".botbuddy", "staging-session-pool");
+}
+
+function lastJsonLine(text) {
+  const lines = String(text ?? "").split("\n").filter((line) => line.startsWith("{"));
+  for (const line of lines.reverse()) {
+    try { return JSON.parse(line); } catch { /* keep looking */ }
+  }
+  return null;
+}
+
+async function refreshOne({ dirName, installedVersion, cliEntry, nodeBin, home, execFileImpl }) {
+  let config;
+  try {
+    config = JSON.parse(await readFile(join(stagingPoolsRoot(home), dirName, "config.json"), "utf8"));
+  } catch (error) {
+    if (error?.code === "ENOENT") return null; // not a pool home
+    return { poolId: dirName, status: "unreadable", code: "config_unreadable", message: `Its config.json could not be read (${error?.message ?? error}).`, next: "bb staging-pool status --check --pool " + dirName, actor: "agent or human" };
+  }
+  const poolId = typeof config?.poolId === "string" ? config.poolId : dirName;
+  const tenant = config?.tenant ?? config?.binding?.tenant ?? null;
+  if (config?.source !== "control-plane" || !tenant) {
+    return { poolId, status: "legacy", code: "installed_before_registry", message: "It was installed before the control-plane registry, so only a human re-install can update it.", next: tenant ? installLine(tenant, poolId) : `bb staging-pool status --pool ${poolId}`, actor: HUMAN_NEXT };
+  }
+  const runtimeVersion = config?.runtime?.version ?? null;
+  if (runtimeVersion === installedVersion) return { poolId, status: "current", runtimeVersion };
+  const retry = `bb staging-pool refresh-runtime --tenant ${tenant} --pool ${poolId}`;
+  try {
+    const { stdout } = await execFileImpl(nodeBin, [cliEntry, "staging-pool", "refresh-runtime", "--tenant", tenant, "--pool", poolId], { timeout: REFRESH_TIMEOUT_MS, maxBuffer: 1024 * 1024 });
+    const receipt = lastJsonLine(stdout);
+    if (receipt?.ok === true) return { poolId, status: "refreshed", runtimeVersion: receipt.runtimeVersion ?? installedVersion };
+    return { poolId, status: "refused", code: receipt?.code ?? "refresh_failed", message: receipt?.message ?? "The refresh printed no success receipt.", next: retry, actor: "agent or human" };
+  } catch (error) {
+    // A refusal is one JSON line on stderr (then text guidance); stdout stays empty.
+    const receipt = lastJsonLine(error?.stderr) ?? lastJsonLine(error?.stdout);
+    if (receipt?.code) {
+      const human = /^human/i.test(String(receipt.actor ?? "")) || /install/.test(String(receipt.next ?? ""));
+      const actor = typeof receipt.actor === "string" && receipt.actor ? (human ? `${receipt.actor}, from Terminal.app or iTerm` : receipt.actor) : (human ? HUMAN_NEXT : "agent or human");
+      return { poolId, status: "refused", code: receipt.code, message: [receipt.message, receipt.detail].filter(Boolean).join(" "), next: receipt.next ?? retry, actor };
+    }
+    return { poolId, status: "refused", code: "refresh_failed", message: `The refresh did not finish (${error?.message ?? error}).`, next: retry, actor: "agent or human" };
+  }
+}
+
+/**
+ * Refresh every control-plane staging pool installed under ~/.botbuddy whose
+ * recorded runtime differs from `installedVersion`, by running the new
+ * package's `staging-pool refresh-runtime`. Reports one line per pool and
+ * never throws for a pool's refusal. Returns [{ poolId, status, ... }].
+ */
+export async function refreshInstalledPools({
+  installedVersion,
+  cliEntry,
+  nodeBin = process.execPath,
+  home = homedir(),
+  execFileImpl = promisify(execFile),
+  log = (line) => console.log(line),
+  stderr = process.stderr,
+} = {}) {
+  let entries;
+  try {
+    entries = await readdir(stagingPoolsRoot(home), { withFileTypes: true });
+  } catch (error) {
+    if (error?.code === "ENOENT") return [];
+    throw error;
+  }
+  const results = [];
+  for (const entry of entries.filter((e) => e.isDirectory()).sort((a, b) => a.name.localeCompare(b.name))) {
+    const result = await refreshOne({ dirName: entry.name, installedVersion, cliEntry, nodeBin, home, execFileImpl });
+    if (!result) continue;
+    results.push(result);
+    if (result.status === "refreshed") log(`✓ Staging pool ${result.poolId} now runs v${result.runtimeVersion}`);
+    else if (result.status === "current") log(`✓ Staging pool ${result.poolId} already runs v${result.runtimeVersion}`);
+    else {
+      try { stderr.write(`! Staging pool ${result.poolId} was not refreshed (${result.code}): ${result.message}\n  Next (${result.actor}): ${result.next}\n`); } catch { /* ignore */ }
+    }
+  }
+  return results;
+}
+
+// The default for `cmdUpdate`: locate the newly installed package and refresh with it.
+export async function refreshPoolsFromNewPackage({ installedVersion, npmBin, shellOpt, probeImpl, log, stderr }) {
+  const root = readNpmGlobalRoot({ npmBin, shellOpt, probeImpl });
+  return refreshInstalledPools({ installedVersion, cliEntry: join(root, "@botbuddy", "cli", "bin", "botbuddy.mjs"), log, stderr });
+}