@drakon-systems/multi-clawd 1.8.11 → 1.9.1

package/dist/session-handover.js

@@ -0,0 +1,117 @@
+import { copyFileSync, mkdirSync, readdirSync, renameSync, rmSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { basename, dirname, join } from "node:path";
+export const SESSION_DIRS_ENV = "MULTI_CLAWD_SESSION_DIRS";
+const SESSION_ID_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{0,127}$/;
+export function resumeSessionId(argv) {
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        let value;
+        if (arg === "--resume" || arg === "-r")
+            value = argv[i + 1];
+        else if (arg.startsWith("--resume="))
+            value = arg.slice("--resume=".length);
+        if (value !== undefined)
+            return SESSION_ID_RE.test(value) ? value : undefined;
+    }
+    return undefined;
+}
+export function effectiveConfigDir(env) {
+    const dir = env.CLAUDE_CONFIG_DIR?.trim();
+    return dir ? dir : join(homedir(), ".claude");
+}
+export function parseSessionDirs(raw) {
+    if (!raw)
+        return [];
+    try {
+        const parsed = JSON.parse(raw);
+        if (!Array.isArray(parsed))
+            return [];
+        return parsed.filter((d) => typeof d === "string" && d.trim().length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+export const nodeHandoverFs = {
+    listDirs(dir) {
+        try {
+            return readdirSync(dir, { withFileTypes: true })
+                .filter((d) => d.isDirectory())
+                .map((d) => d.name);
+        }
+        catch {
+            return [];
+        }
+    },
+    mtimeMs(path) {
+        try {
+            const st = statSync(path);
+            return st.isFile() ? st.mtimeMs : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    },
+};
+export function planSessionHandover(params) {
+    const fs = params.fs ?? nodeHandoverFs;
+    const file = `${params.sessionId}.jsonl`;
+    const dirs = [params.targetDir, ...params.memberDirs.filter((d) => d !== params.targetDir)];
+    let newest;
+    for (const dir of dirs) {
+        const projects = join(dir, "projects");
+        for (const sub of fs.listDirs(projects)) {
+            const path = join(projects, sub, file);
+            const mtime = fs.mtimeMs(path);
+            if (mtime === undefined)
+                continue;
+            if (!newest || mtime > newest.mtime)
+                newest = { dir, sub, path, mtime };
+        }
+    }
+    if (!newest)
+        return { action: "none", reason: "not-found" };
+    if (newest.dir === params.targetDir)
+        return { action: "none", reason: "already-local" };
+    return {
+        action: "copy",
+        from: newest.path,
+        to: join(params.targetDir, "projects", newest.sub, file),
+        fromDir: newest.dir,
+    };
+}
+export function applySessionHandover(plan) {
+    const tmp = join(dirname(plan.to), `.${basename(plan.to)}.handover-${process.pid}`);
+    mkdirSync(dirname(plan.to), { recursive: true, mode: 0o700 });
+    try {
+        copyFileSync(plan.from, tmp);
+        renameSync(tmp, plan.to);
+    }
+    catch (err) {
+        rmSync(tmp, { force: true });
+        throw err;
+    }
+}
+export function handoverForLaunch(argv, env, deps = {}) {
+    const sessionId = resumeSessionId(argv);
+    if (!sessionId)
+        return undefined;
+    const memberDirs = parseSessionDirs(env[SESSION_DIRS_ENV]);
+    if (memberDirs.length === 0)
+        return undefined;
+    const targetDir = effectiveConfigDir(env);
+    try {
+        const plan = planSessionHandover({ sessionId, targetDir, memberDirs, fs: deps.fs });
+        if (plan.action === "none") {
+            return plan.reason === "not-found"
+                ? `resume handover: session ${sessionId.slice(0, 8)} is in no pool account's config dir — leaving the launch as-is`
+                : undefined;
+        }
+        (deps.apply ?? applySessionHandover)(plan);
+        return `resume handover: session ${sessionId.slice(0, 8)} copied from ${plan.fromDir} into ${targetDir} (newer copy)`;
+    }
+    catch (err) {
+        return `resume handover failed for session ${sessionId.slice(0, 8)}: ${err instanceof Error ? err.message : String(err)}`;
+    }
+}

package/dist/setup-core.js

@@ -157,3 +157,28 @@ export function existingAccountDefaults(config, id) {
 export function looksLikeSecretRef(id) {
     return id.includes("://");
 }
+export function buildDirectSetting(account, choice) {
+    switch (choice.kind) {
+        case "skip":
+            return undefined;
+        case "reuse":
+            if (account.native || (!account.oauthTokenRef && !account.oauthTokenFile)) {
+                throw new Error(`account "${account.id}" has no setup-token to reuse — a native or config-dir login needs its own \`claude setup-token\` for the direct route`);
+            }
+            return true;
+        case "ref":
+            if (!isSecretRefShape(choice.ref)) {
+                throw new Error('secret ref must be { "source": "...", "provider": "...", "id": "..." }');
+            }
+            return { tokenRef: choice.ref };
+        case "file": {
+            const path = choice.path?.trim();
+            if (!path)
+                throw new Error("a token file path is required");
+            return { tokenFile: path };
+        }
+    }
+}
+export function canReuseCliTokenForDirect(account) {
+    return !account.native && Boolean(account.oauthTokenRef || account.oauthTokenFile);
+}

package/dist/shim.js

@@ -6,6 +6,7 @@ import { rewriteModelArg } from "./degrade.js";
 import { parseModelLimitError, recordModelLimit } from "./shim-core.js";
 import { canonicalModelId } from "./models.js";
 import { buildRetryEnv, chooseRetryAccount, parseRetryRoster, retryArming, RETRY_ROSTER_ENV, } from "./retry-plan.js";
+import { handoverForLaunch } from "./session-handover.js";
 function resolveClaudeCommand() {
     const override = process.env.MULTI_CLAWD_CLAUDE_BIN;
     if (override) {
@@ -88,6 +89,11 @@ if (modelOverride) {
         process.stderr.write(`[multi-clawd shim] degrading model for this launch → ${modelOverride}\n`);
     }
 }
+{
+    const note = handoverForLaunch(childArgs, process.env);
+    if (note)
+        process.stderr.write(`[multi-clawd shim] ${note}\n`);
+}
 const retryRoster = parseRetryRoster(process.env[RETRY_ROSTER_ENV]);
 const arming = retryArming(childArgs, retryRoster);
 let retryArmed = arming.armed;

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "multi-clawd",
   "name": "multi-clawd",
-  "version": "1.8.11",
+  "version": "1.9.1",
   "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",
@@ -163,9 +163,74 @@
             "defaultModel": {
               "type": "string",
               "description": "Model id used for live probes (openclaw models status). Defaults to claude-fable-5."
+            },
+            "direct": {
+              "description": "Opt this account into the gateway's direct Anthropic route (anthropic/* models) as well as the CLI. `true` reuses the account's own setup-token (oauthTokenRef / oauthTokenFile). A native or config-dir login is a rotating grant that is never copied, so it needs an explicit setup-token: {\"tokenRef\": {...}} or {\"tokenFile\": \"...\"}. `multi-clawd update`/`setup` store it as the OpenClaw auth profile anthropic:<id>, and the plugin keeps auth.order.anthropic in pool-health order. Omit to leave the account CLI-only (unchanged behaviour).",
+              "anyOf": [
+                {
+                  "type": "boolean"
+                },
+                {
+                  "type": "object",
+                  "additionalProperties": false,
+                  "properties": {
+                    "tokenRef": {
+                      "type": "object",
+                      "additionalProperties": true,
+                      "description": "Secret reference resolving to a `claude setup-token` value for THIS account, e.g. {\"source\":\"exec\",\"provider\":\"onepassword\",\"id\":\"op://Vault/Item/field\"}.",
+                      "properties": {
+                        "source": {
+                          "type": "string"
+                        },
+                        "provider": {
+                          "type": "string"
+                        },
+                        "id": {
+                          "type": "string"
+                        }
+                      }
+                    },
+                    "tokenFile": {
+                      "type": "string",
+                      "description": "Path to a 0600 file holding a `claude setup-token` value for THIS account. Mutually exclusive with tokenRef."
+                    },
+                    "profileId": {
+                      "type": "string",
+                      "description": "OpenClaw auth profile id. Default anthropic:<account id>. Must start with anthropic:."
+                    }
+                  }
+                }
+              ]
             }
           }
         }
+      },
+      "directRoute": {
+        "type": "object",
+        "additionalProperties": false,
+        "description": "The gateway's direct Anthropic route (anthropic/* models), active only when at least one account sets `direct`. The plugin keeps each listed agent's auth.order.anthropic in pool-health order (via `openclaw models auth order set`), so a nearly-maxed account is tried last before it errors; OpenClaw's own cooldowns and in-turn rotation handle the rest.",
+        "properties": {
+          "agents": {
+            "type": "array",
+            "items": {
+              "type": "string",
+              "pattern": "^[A-Za-z0-9][A-Za-z0-9_-]{0,63}$"
+            },
+            "description": "Agents whose anthropic auth order is managed. Default [\"main\"]."
+          },
+          "manageOrder": {
+            "type": "boolean",
+            "description": "Keep the order in pool-health order. Default true. false = credentials are still synced by setup/update, the order is left to you."
+          },
+          "intervalMs": {
+            "type": "number",
+            "description": "How often the order is re-planned from health files. Default 60000; minimum 15000. The CLI is only invoked when the plan changes (or hourly to re-assert)."
+          },
+          "openclawCommand": {
+            "type": "string",
+            "description": "OpenClaw CLI used for auth-store reads/writes. Default \"openclaw\" on PATH."
+          }
+        }
       }
     }
   }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@drakon-systems/multi-clawd",
-  "version": "1.8.11",
+  "version": "1.9.1",
   "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. Also imports those accounts' setup tokens into Hermes Agent's Anthropic credential pool.",
   "type": "module",
   "license": "MIT",

package/scripts/cli.mjs

@@ -18,6 +18,7 @@
 import { execFileSync, spawnSync } from "node:child_process";
 import { readFileSync, existsSync as existsSyncEarly } from "node:fs";
 import { dirname, join, resolve } from "node:path";
+import { homedir as osHomedir } from "node:os";
 import { fileURLToPath } from "node:url";
 import readline from "node:readline/promises";
 
@@ -37,6 +38,7 @@ ${BOLD}🦞 multi-clawd${RESET} — multi-account Claude failover for OpenClaw
   ${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}direct${RESET}    the direct anthropic/* route — status, or \`direct sync\` to store profiles
   ${BOLD}update${RESET}    update the plugin to the latest version
   ${BOLD}doctor${RESET}    health check (add --probe for a live turn)
   ${BOLD}hermes${RESET}    sync or diagnose Hermes Agent's Anthropic credential pool
@@ -143,6 +145,195 @@ async function cliSkewNote(cli = cliVersion(), plugin = installedVersion()) {
   }
 }
 
+
+/** The OpenClaw config as parsed JSON, or undefined when unreadable. */
+function readOpenclawConfigSync() {
+  try {
+    return JSON.parse(readFileSync(join(osHomedir(), ".openclaw", "openclaw.json"), "utf8"));
+  } catch {
+    return undefined;
+  }
+}
+
+/**
+ * Everything the direct-route surfaces need, loaded from dist. None of these
+ * modules import the `openclaw` peer, so they load from a global install.
+ * Returns undefined when no account mentions `direct` — callers then print
+ * nothing new (the compatibility contract).
+ */
+async function loadDirect(config) {
+  const pc = config?.plugins?.entries?.["multi-clawd"]?.config ?? {};
+  const accounts = Array.isArray(pc.accounts) ? pc.accounts : [];
+  if (!accounts.some((a) => a && a.direct !== undefined && a.direct !== false)) return undefined;
+  let dr, ds, rep, run, shim;
+  try {
+    dr = await import(resolve(__dirname, "..", "dist", "direct-route.js"));
+    ds = await import(resolve(__dirname, "..", "dist", "direct-sync.js"));
+    rep = await import(resolve(__dirname, "..", "dist", "direct-report.js"));
+    run = await import(resolve(__dirname, "..", "dist", "openclaw-runner.js"));
+    shim = await import(resolve(__dirname, "..", "dist", "shim-core.js"));
+  } catch (err) {
+    console.error(distFailure("direct", "direct-report.js", err));
+    process.exit(1);
+  }
+  const { readFileSync: rf } = await import("node:fs");
+  const { homedir } = await import("node:os");
+  const stateDir = join(homedir(), ".openclaw", "state", "multi-clawd");
+  const pool = pc.pool;
+  const directRoute = pc.directRoute ?? {};
+  const agents = Array.isArray(directRoute.agents) && directRoute.agents.length > 0 ? directRoute.agents : ["main"];
+  const configOrder = Array.isArray(config?.auth?.order?.anthropic) ? config.auth.order.anthropic : undefined;
+  const readHealth = (id) => {
+    try {
+      return shim.parseStoredState(rf(join(stateDir, `${id}.json`), "utf8"));
+    } catch {
+      return undefined;
+    }
+  };
+  let sticky;
+  try {
+    sticky = JSON.parse(rf(join(stateDir, "direct-order.sticky.json"), "utf8"));
+  } catch {
+    /* none */
+  }
+  const runner = run.createOpenclawRunner(directRoute.openclawCommand ?? "openclaw");
+  const healthOptions = {
+    utilizationThreshold: pool?.utilizationThreshold,
+    staleAfterMs: pool?.staleAfterMs,
+    rotateOnOverage: pool?.rotateOnOverage,
+  };
+  const gather = (agentId, opts = {}) =>
+    rep.gatherDirectStatus({
+      accounts,
+      poolAccounts: pool?.accounts ?? [],
+      agentId,
+      runner,
+      readHealth,
+      healthOptions,
+      configOrder,
+      sticky,
+      minDwellMs: pool?.minDwellMs,
+      nowMs: Date.now(),
+      ...opts,
+    });
+  return { dr, ds, rep, runner, accounts, pool, directRoute, agents, configOrder, readHealth, gather, healthOptions, sticky };
+}
+
+/**
+ * `direct` — status (default) or `direct sync`: store each opted-in account's
+ * setup-token as an OpenClaw `anthropic` profile through OpenClaw's own CLI
+ * (secrets apply for refs — no copy; paste-token on stdin for files), then
+ * put every managed agent's order in pool-health order right away instead of
+ * waiting for the gateway's next tick.
+ */
+async function direct(args = []) {
+  const { readFileSync: rf, mkdtempSync, writeFileSync, rmSync, statSync } = await import("node:fs");
+  const { homedir, tmpdir } = await import("node:os");
+  const config = readOpenclawConfigSync();
+  if (!config) {
+    console.error("direct: could not read your OpenClaw config");
+    process.exit(1);
+  }
+  const ctx = await loadDirect(config);
+  const sub = args.find((a) => !a.startsWith("--")) ?? "status";
+  console.log(`\n${BOLD}🦞 multi-clawd — direct anthropic/* route${RESET}\n`);
+  if (!ctx) {
+    console.log("  Not configured: no account sets `direct`, so anthropic/* turns use OpenClaw's own");
+    console.log("  anthropic profiles and the pool steers CLI turns only. See the README (\"Direct route\").\n");
+    return;
+  }
+  if (sub === "sync") {
+    const dryRun = args.includes("--dry-run");
+    const resync = args.includes("--resync");
+    const { members, problems } = ctx.dr.collectDirectMembers(ctx.accounts, ctx.pool?.accounts ?? []);
+    for (const p of problems) console.log(`  ⚠️  ${p.accountId}: skipped — ${p.reason}`);
+    if (members.length === 0) {
+      console.log("  nothing to sync.\n");
+      process.exit(problems.length > 0 ? 1 : 0);
+    }
+    const agentId = ctx.agents[0];
+    if (!dryRun && !args.includes("--yes")) {
+      console.log(`  Will store missing anthropic profiles for agent ${agentId}${resync ? " (and re-store existing ones)" : ""}:`);
+      for (const m of members) console.log(`    ${m.accountId} → ${m.profileId}  (${ctx.rep.describeDirectSource(m)})`);
+      console.log(`  ${DIM}Refs are stored as SecretRefs (secrets apply — the token is never copied). Token files go`);
+      console.log(`  through paste-token on stdin; OpenClaw also records those in its config (auth.profiles/auth.order).${RESET}`);
+      if (!(await askYes("  Proceed?"))) return;
+    }
+    const expand = (p) => (p === "~" ? homedir() : p.startsWith("~/") ? join(homedir(), p.slice(2)) : p);
+    const { results, listError } = await ctx.ds.syncDirectProfiles({
+      members,
+      agentId,
+      runner: ctx.runner,
+      resync,
+      dryRun,
+      readTokenFile: (p) => {
+        const abs = expand(p);
+        const mode = statSync(abs).mode & 0o777;
+        if (mode & 0o077) console.log(`  ⚠️  ${abs} is mode ${mode.toString(8)} — chmod 600 it.`);
+        return rf(abs, "utf8");
+      },
+      writePlanFile: (plan) => {
+        const dir = mkdtempSync(join(tmpdir(), "multi-clawd-plan-"));
+        const path = join(dir, "plan.json");
+        writeFileSync(path, JSON.stringify(plan, null, 2), { mode: 0o600 });
+        return { path, cleanup: () => rmSync(dir, { recursive: true, force: true }) };
+      },
+    });
+    if (listError) {
+      console.error(`  ❌ could not read OpenClaw's anthropic profiles: ${listError}`);
+      process.exit(1);
+    }
+    const icon = { present: "✅", adopted: "✅", stored: "✅", "would-store": "📝", "adopt-missing": "❌", failed: "❌" };
+    for (const r of results) {
+      console.log(`  ${icon[r.action] ?? "•"} ${r.accountId} → ${r.profileId}: ${r.action}${r.detail ? ` (${r.detail})` : ""}`);
+    }
+    const failed = results.filter((r) => r.action === "failed" || r.action === "adopt-missing");
+    if (!dryRun && ctx.directRoute.manageOrder !== false) {
+      for (const agent of ctx.agents) {
+        const status = await ctx.gather(agent, { skipCooldowns: true });
+        if (!status || status.errors.length > 0) {
+          console.log(`  ⚠️  agent ${agent}: order not checked (${status?.errors.join("; ") ?? "no status"})`);
+          continue;
+        }
+        if (!status.pendingOrder) {
+          console.log(`  ✅ agent ${agent}: anthropic order already in pool-health order`);
+          continue;
+        }
+        const r = await ctx.runner(ctx.ds.orderSetArgs(agent, status.pendingOrder), { timeoutMs: 60000 });
+        console.log(
+          r.code === 0
+            ? `  ✅ agent ${agent}: anthropic order → ${status.pendingOrder.join(" → ")}`
+            : `  ❌ agent ${agent}: order set ${ctx.ds.safeCliError(r)}`,
+        );
+        if (r.code !== 0) failed.push({ action: "failed" });
+      }
+    }
+    console.log("");
+    process.exit(failed.length > 0 ? 1 : 0);
+  }
+  // status
+  const ec = await import(resolve(__dirname, "..", "dist", "explain-core.js"));
+  let problems = 0;
+  for (const agent of ctx.agents) {
+    const status = await ctx.gather(agent);
+    if (!status) continue;
+    console.log(`${DIM}agent ${agent}${RESET}`);
+    console.log(ec.renderDirectSection(status.explain, Date.now()).join("\n"));
+    for (const v of status.verdicts) console.log(`  health ${v.accountId}: ${v.verdict}`);
+    if (status.pendingOrder) {
+      console.log(`  ⏳ pending order (the gateway applies it within a minute, or run \`multi-clawd direct sync\`):`);
+      console.log(`     ${status.pendingOrder.join(" → ")}`);
+    }
+    for (const e of status.errors) {
+      problems++;
+      console.log(`  ⚠️  ${e}`);
+    }
+    problems += status.explain.problems.length + status.explain.members.filter((m) => m.stored === false).length;
+    console.log("");
+  }
+  process.exit(problems > 0 ? 1 : 0);
+}
+
 /**
  * `chain` — one place that answers "what actually serves my turns, and does it
  * match what I meant?".
@@ -178,6 +369,14 @@ async function chain(args = []) {
   const pc = config?.plugins?.entries?.["multi-clawd"]?.config ?? {};
   const poolId = pc.pool?.id?.trim() || (pc.pool ? "clawd" : undefined);
   const chainCfg = config?.agents?.defaults?.model;
+  // v1.9: anthropic/* is pooled when the direct route serves two accounts.
+  let directPooled = false;
+  try {
+    const dr = await import(resolve(__dirname, "..", "dist", "direct-route.js"));
+    directPooled = dr.directRoutePools(Array.isArray(pc.accounts) ? pc.accounts : [], pc.directRoute);
+  } catch {
+    /* older dist: no direct route */
+  }
 
   console.log(`\n${BOLD}🦞 multi-clawd — model routing${RESET}\n`);
 
@@ -188,7 +387,10 @@ async function chain(args = []) {
   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}` : ""}`);
+    const directRung = directPooled && /^anthropic\//i.test(r);
+    console.log(
+      `  ${i + 1}. ${r}${pooled ? `  ${DIM}→ pooled${RESET}` : directRung ? `  ${DIM}→ pooled (direct route)${RESET}` : ""}`,
+    );
   });
   console.log("");
 
@@ -209,7 +411,7 @@ async function chain(args = []) {
     `${f.surface} → ${f.ref}`,
   );
 
-  const configFindings = ca.auditEffectiveChain(config, poolId);
+  const configFindings = ca.auditEffectiveChain(config, poolId, { directPooled });
   section(
     "OFF-POOL REFERENCES",
     configFindings.filter((f) => f.severity === "warn"),
@@ -236,7 +438,7 @@ async function chain(args = []) {
         console.log(`${DIM}  (session store ${location.path} not audited: ${read.error} — see doctor)${RESET}`);
         continue;
       }
-      sessionFindings.push(...ca.auditSessionOverrides(read.entries, Boolean(poolId)));
+      sessionFindings.push(...ca.auditSessionOverrides(read.entries, Boolean(poolId), { directPooled }));
     }
   } catch {
     /* no agents dir, or dist not built — doctor reports install health */
@@ -296,6 +498,7 @@ async function update() {
     console.log("  ⏳ remember: the new version loads on the next gateway restart.");
   }
   await healWatchdogUnit();
+  await offerDirectSync();
   await offerCliSelfUpdate(uc);
   console.log(`\n${BOLD}  health check${RESET}`);
   const doc = spawnSync(process.execPath, [join(__dirname, "doctor.mjs")], { stdio: "inherit" });
@@ -306,6 +509,24 @@ async function update() {
   console.log(`\n  ✅ done — now on v${installedVersion() ?? "?"}`);
 }
 
+/**
+ * v1.9: when any account opts into the direct route, store any profile that
+ * is missing and bring the order into health order as part of the update —
+ * the same `direct sync` the operator can run on its own. Skipped silently
+ * when nothing is configured, so updates for CLI-only users are unchanged.
+ */
+async function offerDirectSync() {
+  const config = readOpenclawConfigSync();
+  const accounts = config?.plugins?.entries?.["multi-clawd"]?.config?.accounts ?? [];
+  if (!accounts.some((a) => a && a.direct !== undefined && a.direct !== false)) return;
+  if (!(await askYes("\n  Sync direct-route (anthropic/*) profiles and order now?"))) {
+    console.log(`  ${DIM}Skipped — run \`multi-clawd direct sync\` when you're ready.${RESET}`);
+    return;
+  }
+  const r = spawnSync(process.execPath, [join(__dirname, "cli.mjs"), "direct", "sync", "--yes"], { stdio: "inherit" });
+  if (r.status !== 0) console.log("  ⚠ direct sync reported problems — see above (`multi-clawd direct` for status).");
+}
+
 /**
  * `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.
@@ -475,9 +696,17 @@ async function explain() {
       /* no sticky state */
     }
   }
+  // v1.9: the direct anthropic/* route, when any account opted in.
+  let direct;
+  const dctx = await loadDirect(config);
+  if (dctx) {
+    const status = await dctx.gather(dctx.agents[0]);
+    direct = status?.explain;
+    for (const e of status?.errors ?? []) console.log(`${DIM}(direct route: ${e})${RESET}`);
+  }
   console.log(`\n${BOLD}🦞 multi-clawd — your setup, in plain English${RESET}\n`);
   console.log(
-    ec.renderExplanation({ accounts, pool, chain, health: healthRows, stickyAccount, nowMs: now }),
+    ec.renderExplanation({ accounts, pool, chain, health: healthRows, stickyAccount, nowMs: now, direct }),
   );
   console.log(`\n${DIM}(health checks: multi-clawd doctor · change things: multi-clawd setup)${RESET}`);
 }
@@ -599,6 +828,9 @@ switch (cmd) {
   case "chain":
     await chain(rest);
     break;
+  case "direct":
+    await direct(rest);
+    break;
   case "doctor":
     runSibling("doctor.mjs", rest);
     break;