@drakon-systems/multi-clawd 1.6.0 → 1.7.0

package/README.md

@@ -30,6 +30,7 @@ multi-clawd update    # install (or update) the OpenClaw plugin — right flags,
 multi-clawd setup     # guided wizard: accounts, isolated second login, pool, watchdog
 multi-clawd login claw2   # launch the right Claude sign-in for an account (or re-auth it)
 multi-clawd explain   # your whole setup in plain English — accounts, chain, live health
+multi-clawd chain     # audit your model routing — what actually serves each turn
 multi-clawd doctor    # health check (add --probe for a live end-to-end turn)
 ```
 
@@ -188,7 +189,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.6.0/SETUP-AGENT.md
+> Read https://raw.githubusercontent.com/Drakon-Systems-Ltd/multi-clawd/v1.7.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/chain-audit.js

@@ -164,6 +164,69 @@ export function auditEffectiveChain(config, poolId) {
     }
     return findings;
 }
+function primaryOf(value) {
+    if (typeof value === "string")
+        return value;
+    if (value && typeof value === "object") {
+        const p = value.primary;
+        if (typeof p === "string")
+            return p;
+    }
+    return undefined;
+}
+function collectAgentModelBlocks(config) {
+    const cfg = (config ?? {});
+    const agents = (cfg.agents ?? {});
+    const out = [];
+    for (const [name, v] of Object.entries(agents)) {
+        if (RESERVED_AGENT_KEYS.has(name))
+            continue;
+        if (!v || typeof v !== "object")
+            continue;
+        const agent = v;
+        if ("model" in agent)
+            out.push({ agent: name, surface: `agents.${name}.model`, model: agent.model });
+    }
+    if (Array.isArray(agents.list)) {
+        agents.list.forEach((a, i) => {
+            if (!a || typeof a !== "object")
+                return;
+            const agent = a;
+            if (!("model" in agent))
+                return;
+            const label = typeof agent.id === "string" ? agent.id : String(i);
+            out.push({ agent: label, surface: `agents.list[${label}].model`, model: agent.model });
+        });
+    }
+    return out;
+}
+export function auditChainShadowing(config) {
+    const cfg = (config ?? {});
+    const agents = (cfg.agents ?? {});
+    const defaults = (agents.defaults ?? {});
+    const defaultPrimary = primaryOf(defaults.model);
+    const findings = [];
+    for (const { agent, surface, model } of collectAgentModelBlocks(config)) {
+        const agentPrimary = primaryOf(model);
+        const diverges = agentPrimary !== undefined && agentPrimary !== defaultPrimary;
+        findings.push({
+            surface,
+            ref: agentPrimary ?? "(no primary)",
+            severity: diverges ? "warn" : "note",
+            agent,
+            defaultPrimary,
+            agentPrimary,
+            reason: diverges
+                ? `agent "${agent}" has its OWN chain, so it serves ${agentPrimary} — NOT the ` +
+                    `${defaultPrimary ?? "(unset)"} in agents.defaults.model. Editing the defaults will not ` +
+                    `change this agent. Fix: update this block too, or delete it to inherit the defaults`
+                : `agent "${agent}" repeats the default chain — harmless, but it will silently ` +
+                    `stop tracking agents.defaults.model the next time you change it. Fix: delete this ` +
+                    `block to inherit the defaults`,
+        });
+    }
+    return findings;
+}
 const POOL_PROVIDER = "clawd";
 export function auditSessionOverrides(sessions, poolConfigured) {
     if (!poolConfigured)

package/dist/index.js

@@ -15,6 +15,7 @@ import { createTokenRefResolver, isSecretRefShape, } from "./token-resolution.js
 import { resolveSecretRefValues } from "openclaw/plugin-sdk/secret-ref-runtime";
 import { addAlert, clearAlert, pendingAlertText } from "./alerts.js";
 import { buildAccountChildEnv, tokenFileModeWarning, validateAccountTokenSources, } from "./account-env.js";
+import { diffCatalogModels, formatNewModelNotice, } from "./model-currency.js";
 import { checkAccountCredential, createRefProbeTracker, } from "./login-health.js";
 import { execFileSync } from "node:child_process";
 const BASE_ARGS = [
@@ -231,6 +232,54 @@ const SHIM_PATH = fileURLToPath(new URL("./shim.js", import.meta.url));
 export function healthStateFile(accountId) {
     return join(homedir(), ".openclaw", "state", "multi-clawd", `${accountId}.json`);
 }
+function knownModelsFile() {
+    return join(homedir(), ".openclaw", "state", "multi-clawd", "known-models.json");
+}
+function readChainRefs() {
+    try {
+        const cfg = JSON.parse(readFileSync(join(homedir(), ".openclaw", "openclaw.json"), "utf8"));
+        const m = cfg?.agents?.defaults?.model;
+        const refs = [];
+        if (typeof m?.primary === "string")
+            refs.push(m.primary);
+        if (Array.isArray(m?.fallbacks)) {
+            for (const f of m.fallbacks)
+                if (typeof f === "string")
+                    refs.push(f);
+        }
+        return refs;
+    }
+    catch {
+        return [];
+    }
+}
+function checkModelCurrency(catalogIds, chainRefs, poolId) {
+    try {
+        const file = knownModelsFile();
+        let stored;
+        try {
+            stored = JSON.parse(readFileSync(file, "utf8"));
+        }
+        catch {
+        }
+        const result = diffCatalogModels(stored, catalogIds, chainRefs, Date.now());
+        mkdirSync(dirname(file), { recursive: true });
+        const tmp = `${file}.tmp`;
+        writeFileSync(tmp, JSON.stringify(result.nextState, null, 2), { mode: 0o600 });
+        renameSync(tmp, file);
+        const notice = formatNewModelNotice(result.unusedNewIds, poolId);
+        if (notice) {
+            raiseAlert({
+                key: `new-models:${result.unusedNewIds.join(",")}`,
+                severity: "info",
+                text: notice,
+                ttlMs: 24 * 60 * 60 * 1000,
+            });
+        }
+    }
+    catch {
+    }
+}
 export function buildBackend(account, execMode) {
     return {
         id: account.id,
@@ -520,4 +569,11 @@ function registerPoolBackend(api, pool, accounts, registeredIds, execMode) {
     api.registerProvider(buildCatalogProvider(poolAccount));
     registeredIds.add(poolId);
     logger.info(`[multi-clawd] pool "${poolId}" active — accounts: ${memberIds.join(" → ")}, threshold: ${options.utilizationThreshold ?? 0.85}`);
+    void (async () => {
+        try {
+            checkModelCurrency(await resolveBaseModelIds(), readChainRefs(), poolId);
+        }
+        catch {
+        }
+    })();
 }

package/dist/model-currency.js

@@ -0,0 +1,26 @@
+import { isModernClaudeModelId } from "./models.js";
+function modelIdOf(ref) {
+    const i = ref.indexOf("/");
+    return i < 0 ? ref : ref.slice(i + 1);
+}
+export function diffCatalogModels(stored, catalogIds, chainRefs, nowMs) {
+    const claudeIds = [...new Set(catalogIds.filter(isModernClaudeModelId))].sort();
+    const nextState = { ids: claudeIds, updatedAt: nowMs };
+    const firstRun = !stored || !Array.isArray(stored.ids) || stored.ids.length === 0;
+    if (firstRun)
+        return { newIds: [], unusedNewIds: [], nextState, firstRun: true };
+    const seen = new Set(stored.ids);
+    const newIds = claudeIds.filter((id) => !seen.has(id));
+    const referenced = new Set(chainRefs.map(modelIdOf));
+    const unusedNewIds = newIds.filter((id) => !referenced.has(id));
+    return { newIds, unusedNewIds, nextState, firstRun: false };
+}
+export function formatNewModelNotice(unusedNewIds, poolId) {
+    if (unusedNewIds.length === 0)
+        return undefined;
+    const list = unusedNewIds.map((id) => `${poolId}/${id}`).join(", ");
+    const subject = unusedNewIds.length === 1 ? "A new Claude model is" : "New Claude models are";
+    return (`${subject} available on your accounts but not referenced in your chain: ${list}. ` +
+        `Whether it belongs as your primary, a fallback, or nowhere is your call — ` +
+        `run \`multi-clawd chain\` to see your current routing.`);
+}

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "multi-clawd",
   "name": "multi-clawd",
-  "version": "1.6.0",
+  "version": "1.7.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.6.0",
+  "version": "1.7.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

@@ -35,6 +35,7 @@ ${BOLD}🦞 multi-clawd${RESET} — multi-account Claude failover for OpenClaw
   ${BOLD}setup${RESET}     guided setup wizard (accounts, pool, watchdog)
   ${BOLD}login${RESET}     log a configured account in (or re-auth it) — right dir, right env
   ${BOLD}explain${RESET}   your setup in plain English — accounts, pool, fallback chain
+  ${BOLD}chain${RESET}     audit your model routing — what actually serves each turn
   ${BOLD}update${RESET}    update the plugin to the latest version
   ${BOLD}doctor${RESET}    health check (add --probe for a live turn)
   ${BOLD}version${RESET}   show CLI + installed plugin versions
@@ -112,6 +113,114 @@ async function cliSkewNote(cli = cliVersion(), plugin = installedVersion()) {
   }
 }
 
+/**
+ * `chain` — one place that answers "what actually serves my turns, and does it
+ * match what I meant?".
+ *
+ * Every routing fault this project has hit was config that no longer matched
+ * intent: a per-agent chain shadowing the defaults, sessions pinned off-pool,
+ * allowlist rungs naming retired providers. Each was individually invisible and
+ * each defeated cross-account failover — the entire point of the product. The
+ * audits already existed for doctor; this gives them a home where the fix is
+ * printed next to the finding.
+ */
+async function chain(args = []) {
+  const { readFileSync: rf, existsSync, readdirSync } = await import("node:fs");
+  const { homedir } = await import("node:os");
+  const raw = args.includes("--raw");
+
+  let ca;
+  try {
+    ca = await import(resolve(__dirname, "..", "dist", "chain-audit.js"));
+  } catch {
+    console.error("chain: built dist/ is missing — reinstall the package.");
+    process.exit(1);
+  }
+
+  let config;
+  try {
+    config = JSON.parse(rf(join(homedir(), ".openclaw", "openclaw.json"), "utf8"));
+  } catch {
+    console.error("chain: could not read ~/.openclaw/openclaw.json");
+    process.exit(1);
+  }
+
+  const pc = config?.plugins?.entries?.["multi-clawd"]?.config ?? {};
+  const poolId = pc.pool?.id?.trim() || (pc.pool ? "clawd" : undefined);
+  const chainCfg = config?.agents?.defaults?.model;
+
+  console.log(`\n${BOLD}🦞 multi-clawd — model routing${RESET}\n`);
+
+  console.log(`${BOLD}DEFAULT CHAIN${RESET}  ${DIM}(agents.defaults.model)${RESET}`);
+  const rungs = [chainCfg?.primary, ...(chainCfg?.fallbacks ?? [])].filter(
+    (r) => typeof r === "string",
+  );
+  if (rungs.length === 0) console.log("  (none configured)");
+  rungs.forEach((r, i) => {
+    const pooled = poolId && r.startsWith(`${poolId}/`);
+    console.log(`  ${i + 1}. ${r}${pooled ? `  ${DIM}→ pooled${RESET}` : ""}`);
+  });
+  console.log("");
+
+  let problems = 0;
+  const section = (title, findings, renderRef) => {
+    if (findings.length === 0) return;
+    console.log(`${BOLD}${title}${RESET}`);
+    for (const f of findings) {
+      const icon = f.severity === "warn" ? "⚠️ " : "ℹ️ ";
+      if (f.severity === "warn") problems++;
+      console.log(`  ${icon} ${renderRef(f)}`);
+      console.log(`      ${DIM}${f.reason}${RESET}`);
+    }
+    console.log("");
+  };
+
+  section("AGENTS WITH THEIR OWN CHAIN", ca.auditChainShadowing(config), (f) =>
+    `${f.surface} → ${f.ref}`,
+  );
+
+  const configFindings = ca.auditEffectiveChain(config, poolId);
+  section(
+    "OFF-POOL REFERENCES",
+    configFindings.filter((f) => f.severity === "warn"),
+    (f) => `${f.surface}: ${f.ref}`,
+  );
+  const notes = configFindings.filter((f) => f.severity === "note");
+  if (notes.length > 0) {
+    console.log(
+      `${DIM}  (${notes.length} allowlist entr${notes.length === 1 ? "y" : "ies"} name a non-pool Claude ref — registered, not a live tier)${RESET}\n`,
+    );
+  }
+
+  // Session pins, across every agent's session store.
+  const sessionFindings = [];
+  const agentsDir = join(homedir(), ".openclaw", "agents");
+  try {
+    for (const agent of readdirSync(agentsDir)) {
+      const p = join(agentsDir, agent, "sessions", "sessions.json");
+      if (!existsSync(p)) continue;
+      try {
+        sessionFindings.push(...ca.auditSessionOverrides(JSON.parse(rf(p, "utf8")), Boolean(poolId)));
+      } catch {
+        /* unreadable store — skip, doctor reports install health */
+      }
+    }
+  } catch {
+    /* no agents dir */
+  }
+  section("SESSION PINS", sessionFindings, (f) =>
+    raw ? f.surface : f.surface.replace(/^session (.*)$/, (_, k) => `session ${ca.maskSessionKey(k)}`),
+  );
+
+  if (problems === 0) {
+    console.log(`✅ routing is consistent — every live Claude tier goes through the pool.\n`);
+  } else {
+    console.log(
+      `${problems} thing${problems === 1 ? "" : "s"} to look at. ${DIM}Session ids are masked; --raw shows them in full.${RESET}\n`,
+    );
+  }
+}
+
 async function update() {
   let uc;
   try {
@@ -439,6 +548,9 @@ switch (cmd) {
   case "explain":
     await explain();
     break;
+  case "chain":
+    await chain(rest);
+    break;
   case "doctor":
     runSibling("doctor.mjs", rest);
     break;