@drakon-systems/multi-clawd 1.5.3 → 1.6.0

package/README.md

@@ -188,7 +188,7 @@ openclaw plugins install (Get-Location).Path
 **Or let your agent install it.** Running an OpenClaw assistant or Claude
 Code on the target machine already? Paste it this and go make coffee:
 
-> Read https://raw.githubusercontent.com/Drakon-Systems-Ltd/multi-clawd/v1.5.3/SETUP-AGENT.md
+> Read https://raw.githubusercontent.com/Drakon-Systems-Ltd/multi-clawd/v1.6.0/SETUP-AGENT.md
 > and follow it to set up multi-clawd on this machine. I own a second
 > Claude account — ask me when you need me to log in.
 

package/dist/update-core.js

@@ -15,6 +15,48 @@ export function decideUpdateAction(opts) {
         return "unknown";
     return compareVersions(opts.installed, opts.latest) < 0 ? "update" : "up-to-date";
 }
+export function classifyCliSkew(opts) {
+    if (opts.pluginVersion === undefined)
+        return "plugin-missing";
+    const d = compareVersions(opts.cliVersion, opts.pluginVersion);
+    if (d === 0)
+        return "aligned";
+    return d < 0 ? "cli-behind" : "cli-ahead";
+}
+export function detectCliInstallKind(cliDir) {
+    if (/[/\\]_npx[/\\]/.test(cliDir))
+        return "npx";
+    if (/[/\\]node_modules[/\\]/.test(cliDir))
+        return "global";
+    return "source";
+}
+export function cliUpdateCommand(kind, pkg) {
+    switch (kind) {
+        case "global":
+            return `npm i -g ${pkg}@latest`;
+        case "npx":
+            return `npx ${pkg}@latest <command>`;
+        case "source":
+            return "git pull && npm run build";
+    }
+}
+export function formatCliSkew(opts) {
+    const skew = classifyCliSkew(opts);
+    const fix = cliUpdateCommand(opts.installKind, opts.pkg);
+    switch (skew) {
+        case "aligned":
+            return undefined;
+        case "plugin-missing":
+            return undefined;
+        case "cli-behind":
+            return (`CLI v${opts.cliVersion} is older than the installed plugin v${opts.pluginVersion} — ` +
+                `\`doctor\`/\`setup\` run from the CLI, so this one reports on the plugin using ` +
+                `older logic. Fix: ${fix}`);
+        case "cli-ahead":
+            return (`CLI v${opts.cliVersion} is newer than the installed plugin v${opts.pluginVersion} — ` +
+                `the plugin serving your turns is behind. Fix: multi-clawd update`);
+    }
+}
 export function formatUpdateBanner(opts) {
     const action = decideUpdateAction(opts);
     switch (action) {

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "multi-clawd",
   "name": "multi-clawd",
-  "version": "1.5.3",
+  "version": "1.6.0",
   "description": "Register additional Claude Code logins (Max/Pro accounts) as first-class OpenClaw CLI backends for cross-account failover, keeping the full skills/MCP harness on every account.",
   "cliBackends": [
     "claw1",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drakon-systems/multi-clawd",
-  "version": "1.5.3",
+  "version": "1.6.0",
   "description": "Multi-account Claude Code failover for OpenClaw — register additional Claude (Max/Pro) logins as first-class CLI backends and keep the full skills/MCP harness across every account.",
   "type": "module",
   "license": "MIT",

package/scripts/cli.mjs

@@ -88,6 +88,30 @@ async function askYes(question, dflt = true) {
   return a.startsWith("y");
 }
 
+/** This package's own version (the CLI half). */
+function cliVersion() {
+  return JSON.parse(readFileSync(resolve(__dirname, "..", "package.json"), "utf8")).version;
+}
+
+/**
+ * Skew advice for the current install, or undefined when the two halves agree.
+ * Loads the pure classifier from dist; stays silent if dist is unavailable so
+ * a missing build can never turn an informational note into a hard failure.
+ */
+async function cliSkewNote(cli = cliVersion(), plugin = installedVersion()) {
+  try {
+    const uc = await import(resolve(__dirname, "..", "dist", "update-core.js"));
+    return uc.formatCliSkew({
+      cliVersion: cli,
+      pluginVersion: plugin,
+      installKind: uc.detectCliInstallKind(resolve(__dirname, "..")),
+      pkg: PKG,
+    });
+  } catch {
+    return undefined;
+  }
+}
+
 async function update() {
   let uc;
   try {
@@ -130,6 +154,7 @@ async function update() {
     console.log("  ⏳ remember: the new version loads on the next gateway restart.");
   }
   await healWatchdogUnit();
+  await offerCliSelfUpdate(uc);
   console.log(`\n${BOLD}  health check${RESET}`);
   const doc = spawnSync(process.execPath, [join(__dirname, "doctor.mjs")], { stdio: "inherit" });
   if (doc.status !== 0) {
@@ -139,6 +164,46 @@ async function update() {
   console.log(`\n  ✅ done — now on v${installedVersion() ?? "?"}`);
 }
 
+/**
+ * `update` upgrades the PLUGIN; this finishes the job by offering to upgrade
+ * the CLI too, so "update" means what a user reasonably assumes it means.
+ *
+ * Runs LAST in the update flow on purpose: `npm i -g` replaces this package's
+ * own directory, so nothing may dynamically import from it afterwards. Skipped
+ * silently when the halves already agree, and never forced — a global install
+ * can need permissions we shouldn't assume, and npx users have nothing to
+ * update at all.
+ */
+async function offerCliSelfUpdate(uc) {
+  const cli = cliVersion();
+  const plugin = installedVersion();
+  if (uc.classifyCliSkew({ cliVersion: cli, pluginVersion: plugin }) !== "cli-behind") return;
+
+  const kind = uc.detectCliInstallKind(resolve(__dirname, ".."));
+  const fix = uc.cliUpdateCommand(kind, PKG);
+  console.log(
+    `\n  ⚠️  Your ${BOLD}multi-clawd${RESET} command is v${cli} but the plugin is now v${plugin}.`,
+  );
+  console.log(
+    `     ${DIM}doctor and setup run from the command, so they'd report on the new plugin using old logic.${RESET}`,
+  );
+
+  if (kind !== "global") {
+    console.log(`     Bring it up to date with: ${BOLD}${fix}${RESET}`);
+    return;
+  }
+  if (!(await askYes(`     Update the command now? (${fix})`))) {
+    console.log(`     ${DIM}Skipped — run \`${fix}\` when you're ready.${RESET}`);
+    return;
+  }
+  const r = spawnSync("npm", ["i", "-g", `${PKG}@latest`], { stdio: "inherit" });
+  if (r.status === 0) {
+    console.log(`  ✅ command updated — the new version applies from your next run.`);
+  } else {
+    console.log(`  ⚠ that failed (permissions?) — run it yourself: ${BOLD}${fix}${RESET}`);
+  }
+}
+
 /**
  * Self-heal the scheduled watchdog after an update: the npm install dir is
  * regenerated on every update, so a unit pointing into it just orphaned.
@@ -386,8 +451,13 @@ switch (cmd) {
     const cliVersion = JSON.parse(
       readFileSync(resolve(__dirname, "..", "package.json"), "utf8"),
     ).version;
+    const pluginVersion = installedVersion();
     console.log(`cli: v${cliVersion}`);
-    console.log(`installed plugin: ${installedVersion() ? `v${installedVersion()}` : "(not installed)"}`);
+    console.log(`installed plugin: ${pluginVersion ? `v${pluginVersion}` : "(not installed)"}`);
+    // Two versions printed side by side invite exactly one question — "is that
+    // a problem?" — so answer it here rather than leaving the reader to guess.
+    const skewNote = await cliSkewNote(cliVersion, pluginVersion);
+    if (skewNote) console.log(`\n⚠️  ${skewNote}`);
     break;
   }
   default:

package/scripts/doctor.mjs

@@ -114,6 +114,31 @@ const entry = config?.plugins?.entries?.["multi-clawd"];
 const pluginConfig = entry?.config ?? {};
 if (!manifest) bad(`no installed manifest at ${EXT_DIR}`);
 else ok(`installed at ${EXT_DIR}`);
+
+// Doctor itself ships in the CLI half, so a stale CLI means these very
+// findings were produced by older logic than the plugin they describe. That
+// has to be the first thing reported, or every line below is suspect.
+{
+  // REPO_DIR first, unlike the health imports below: this is CLI-side logic and
+  // doctor IS the CLI half, so it must use its own copy. Reaching for the
+  // plugin's copy would ask a possibly-older artifact whether it is older.
+  const uc = await import(join(REPO_DIR, "dist", "update-core.js")).catch(() =>
+    import(join(EXT_DIR, "dist", "update-core.js")).catch(() => undefined),
+  );
+  const cliVer = readJson(join(REPO_DIR, "package.json"))?.version;
+  const pluginVer = manifest?.version;
+  const note =
+    uc && cliVer && typeof uc.formatCliSkew === "function"
+      ? uc.formatCliSkew({
+          cliVersion: cliVer,
+          pluginVersion: pluginVer,
+          installKind: uc.detectCliInstallKind(REPO_DIR),
+          pkg: "@drakon-systems/multi-clawd",
+        })
+      : undefined;
+  if (note) warn(note);
+  else if (cliVer && pluginVer) ok(`CLI and plugin both v${cliVer}`);
+}
 if (!entry) bad("no plugins.entries[\"multi-clawd\"] in openclaw.json");
 else if (entry.enabled !== true) bad("plugin entry present but not enabled");
 else ok("plugin entry enabled");
@@ -182,6 +207,9 @@ console.log("account credentials");
 const { checkAccountCredential } = await import(join(EXT_DIR, "dist", "login-health.js")).catch(
   () => import(join(REPO_DIR, "dist", "login-health.js")),
 );
+const { summarizeWindowUsage } = await import(join(EXT_DIR, "dist", "health.js")).catch(() =>
+  import(join(REPO_DIR, "dist", "health.js")),
+);
 const io = {
   readFile: (p) => readFileSync(expandHome(p), "utf8"),
   keychainHasClaudeCredentials: () => {
@@ -218,10 +246,32 @@ for (const account of accounts) {
     continue;
   }
   const ageMin = Math.round((Date.now() - (state.updatedAt ?? 0)) / 60000);
+  // A window whose own reset has PASSED describes the previous cycle, and the
+  // rotation logic already voids it ("a passed reset voids the observation",
+  // health.ts). Doctor used to print it raw beside a fresh `(0m old)` stamp,
+  // so a five-day-dead `seven_day@96%` read as "96% used right now" when
+  // nothing was acting on it. The age stamp is the age of the OBSERVATION,
+  // never the window's validity.
+  //
+  // `summarizeWindowUsage` is the same function `explain` uses, so all three
+  // surfaces — rotation, explain, doctor — agree on what counts as live
+  // rather than each carrying its own copy of the rule.
+  const live = new Set(
+    summarizeWindowUsage(state, { staleAfterMs: pluginConfig.pool?.staleAfterMs }, Date.now()).map(
+      (u) => u.window,
+    ),
+  );
   const windows = Object.entries(state.windows ?? {})
-    .map(([w, d]) => `${w}:${d.status}${typeof d.utilization === "number" ? `@${Math.round(d.utilization * 100)}%` : ""}`)
+    .map(([w, d]) => {
+      const hasUtil = typeof d.utilization === "number";
+      const util = hasUtil ? `@${Math.round(d.utilization * 100)}%` : "";
+      // Only utilization-bearing account windows are summarised; a window
+      // carrying a number that did NOT survive is one the pool ignores.
+      const stale = hasUtil && !w.startsWith("model:") && !live.has(w);
+      return `${w}:${d.status}${util}${stale ? " (expired — ignored)" : ""}`;
+    })
     .join(" ");
-  ok(`${account.id}: ${windows || "no windows"} (${ageMin}m old)`);
+  ok(`${account.id}: ${windows || "no windows"} (observed ${ageMin}m ago)`);
 }
 
 // ── 6. pool ─────────────────────────────────────────────────────────────────