@drakon-systems/multi-clawd 1.8.10 → 1.9.1

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;

package/scripts/doctor.mjs

@@ -527,6 +527,14 @@ if (!pool) {
     "cli",
   );
   const poolId = pool.id ?? "clawd";
+  // v1.9: anthropic/* rungs are pooled when the direct route serves two accounts.
+  let directPooled = false;
+  try {
+    const dr = await importDist("direct-route.js", ["directRoutePools"], "cli");
+    directPooled = dr.directRoutePools(accounts, pluginConfig.directRoute);
+  } catch {
+    /* dist predates the direct route */
+  }
   // Session keys embed the operator's private channel id (e.g. a Telegram chat
   // id). Mask the id tail by default so doctor output is safe to paste into
   // issues/support threads; `--raw` (hoisted, shared with the login identities
@@ -536,7 +544,7 @@ if (!pool) {
     RAW ? surface : surface.replace(/^session (.+)$/, (_m, k) => `session ${maskSessionKey(k)}`);
 
   // ── case 1: config-level refs ──────────────────────────────────────────────
-  const findings = auditEffectiveChain(config, poolId);
+  const findings = auditEffectiveChain(config, poolId, { directPooled });
   const warns = findings.filter((f) => f.severity === "warn");
   const notes = findings.filter((f) => f.severity === "note");
   for (const f of warns) warn(`${f.surface}: ${f.ref} ${f.reason}`);
@@ -593,7 +601,7 @@ if (!pool) {
       if (read.skippedRows > 0) {
         warn(`${location.path}: ${read.skippedRows} session row(s) unparseable — those sessions were not audited`);
       }
-      const sessionFindings = auditSessionOverrides(read.entries, true);
+      const sessionFindings = auditSessionOverrides(read.entries, true, { directPooled });
       for (const f of sessionFindings) {
         warn(`${renderSurface(f.surface)}: ${f.ref} ${f.reason}`);
         sessionWarns++;
@@ -703,6 +711,113 @@ console.log("chain auth");
   }
 }
 
+
+// ── 8b. direct route — anthropic/* served by the pool's accounts (v1.9) ────
+//
+// Only when an account opts in with `direct`; otherwise this prints nothing,
+// so doctor output for CLI-only setups is unchanged. Everything is read
+// through OpenClaw's own CLI (auth list / order get / models status); token
+// files are shape-checked without ever printing their contents.
+if (accounts.some((a) => a && a.direct !== undefined && a.direct !== false)) {
+  console.log("direct route (anthropic/*)");
+  try {
+    const dr = await importDist("direct-route.js", ["collectDirectMembers"], "cli");
+    const rep = await importDist("direct-report.js", ["gatherDirectStatus", "parseProbeResults", "probeArgs"], "cli");
+    const run = await importDist("openclaw-runner.js", ["createOpenclawRunner"], "cli");
+    const shim = await importDist("shim-core.js", ["parseStoredState"], "cli");
+    const hc = await importDist("hermes-core.js", ["parseClaudeSetupToken"], "cli");
+    const directRoute = pluginConfig.directRoute ?? {};
+    const agents = Array.isArray(directRoute.agents) && directRoute.agents.length > 0 ? directRoute.agents : ["main"];
+    const runner = run.createOpenclawRunner(directRoute.openclawCommand ?? "openclaw");
+    const { members } = dr.collectDirectMembers(accounts, pool?.accounts ?? []);
+    // Credential sources, checked locally: present, private, setup-token shaped.
+    for (const m of members) {
+      if (m.source.kind !== "file") continue;
+      const path = expandHome(m.source.path);
+      try {
+        const mode = statSync(path).mode & 0o777;
+        hc.parseClaudeSetupToken(readFileSync(path, "utf8"));
+        if (mode & 0o077) warn(`${m.accountId}: direct token file ${path} is mode ${mode.toString(8)} — chmod 600 it`);
+        else ok(`${m.accountId}: direct token file present, 600, setup-token shaped`);
+      } catch (err) {
+        bad(`${m.accountId}: direct token file ${path} unusable — ${String(err?.message ?? err).slice(0, 160)}`);
+      }
+    }
+    const readHealth = (id) => {
+      try {
+        return shim.parseStoredState(readFileSync(join(STATE_DIR, `${id}.json`), "utf8"));
+      } catch {
+        return undefined;
+      }
+    };
+    for (const agentId of agents) {
+      const status = await rep.gatherDirectStatus({
+        accounts,
+        poolAccounts: pool?.accounts ?? [],
+        agentId,
+        runner,
+        readHealth,
+        healthOptions: {
+          utilizationThreshold: pool?.utilizationThreshold,
+          staleAfterMs: pool?.staleAfterMs,
+          rotateOnOverage: pool?.rotateOnOverage,
+        },
+        configOrder: Array.isArray(config?.auth?.order?.anthropic) ? config.auth.order.anthropic : undefined,
+        sticky: readJson(join(STATE_DIR, "direct-order.sticky.json")),
+        minDwellMs: pool?.minDwellMs,
+        nowMs: Date.now(),
+      });
+      if (!status) continue;
+      for (const p of status.explain.problems) bad(`${p.accountId}: asked for the direct route but cannot join it — ${p.reason}`);
+      for (const e of status.errors) warn(`agent ${agentId}: direct-route check partly SKIPPED — ${e}`);
+      for (const m of status.explain.members) {
+        const v = status.verdicts.find((x) => x.accountId === m.accountId)?.verdict ?? "no_data";
+        if (m.stored === false) {
+          bad(
+            m.adopted
+              ? `${m.accountId}: adopted profile ${m.profileId} is NOT stored for agent ${agentId} — store it yourself (openclaw models auth paste-token --provider anthropic --profile-id ${m.profileId}) or fix direct.profileId`
+              : `${m.accountId}: ${m.profileId} is NOT stored for agent ${agentId} — run \`multi-clawd direct sync\``,
+          );
+        }
+        else if (m.stored === true) ok(`${m.accountId}: ${m.profileId} stored for agent ${agentId} (health: ${v})`);
+        if (m.cooldownUntil && m.cooldownUntil > Date.now()) {
+          note(`${m.profileId} is cooling down (${m.cooldownReason ?? "cooldown"}) for ~${Math.ceil((m.cooldownUntil - Date.now()) / 60000)}m — OpenClaw skips it until then`);
+        }
+      }
+      if (directRoute.manageOrder === false) {
+        note(`agent ${agentId}: order management is off (directRoute.manageOrder: false)`);
+      } else if (status.pendingOrder) {
+        warn(
+          `agent ${agentId}: anthropic order is not in pool-health order yet — the gateway applies ${status.pendingOrder.join(" → ")} within a minute once this version is loaded (or run \`multi-clawd direct sync\`)`,
+        );
+      } else if (status.errors.length === 0) {
+        ok(`agent ${agentId}: anthropic order is in pool-health order (${(status.explain.order ?? []).join(" → ")})`);
+      }
+      const unmanaged = (status.explain.order ?? []).filter((id) => !status.explain.members.some((m) => m.profileId === id));
+      if (unmanaged.length > 0) {
+        note(`agent ${agentId}: ${unmanaged.join(", ")} not managed by multi-clawd — kept after the pool's accounts`);
+      }
+      // Live probe: one tiny call per stored managed profile.
+      if (args.has("--probe") && !args.has("--probe-pool")) {
+        const ids = status.explain.members.filter((m) => m.stored).map((m) => m.profileId);
+        if (ids.length > 0) {
+          const r = await runner(rep.probeArgs(agentId, ids), { timeoutMs: 180000 });
+          const results = r.code === 0 ? rep.parseProbeResults(r.stdout) : undefined;
+          if (!results) warn(`agent ${agentId}: direct-route probe returned nothing parseable (exit ${r.code})`);
+          for (const id of ids) {
+            const res = results?.find((x) => x.profileId === id);
+            if (!res) continue;
+            if (res.status === "ok") ok(`${id}: live probe answered via the direct API`);
+            else bad(`${id}: live probe ${res.status}${res.error ? ` — ${res.error}` : ""}`);
+          }
+        }
+      }
+    }
+  } catch (err) {
+    warn(`direct-route check SKIPPED — ${String(err?.message ?? err).split("\n")[0].slice(0, 160)}`);
+  }
+}
+
 // ── 9. watchdog ─────────────────────────────────────────────────────────────
 console.log("eviction watchdog");
 let watchdogFound = false;

package/scripts/setup.mjs

@@ -41,7 +41,7 @@ try {
   console.error("setup: built dist/ modules are missing — run `npm run build` first (source checkout) or reinstall the plugin.");
   process.exit(1);
 }
-const { buildMainAccount, buildSecondAccount, buildPool, validateSecondConfigDir, planFromExisting, mergeSetupIntoConfig, existingAccountDefaults, looksLikeSecretRef } = core;
+const { buildMainAccount, buildSecondAccount, buildPool, validateSecondConfigDir, planFromExisting, mergeSetupIntoConfig, existingAccountDefaults, looksLikeSecretRef, buildDirectSetting, canReuseCliTokenForDirect } = core;
 
 // Line-queued prompts: interactive AND pipe-safe. With piped stdin, readline
 // emits every buffered line immediately — a plain question() would capture one
@@ -210,6 +210,70 @@ if (accounts.length === 0 && state.accountIds.length === 0) {
   process.exit(0);
 }
 
+// ── direct route (v1.9, optional) ────────────────────────────────────────────
+// The gateway's own anthropic/* models call the Anthropic API directly with an
+// OpenClaw auth profile. Opting accounts in lets the pool steer those turns too
+// (by keeping the auth-profile order in pool-health order). Default NO: an
+// account without `direct` behaves exactly as before.
+let directConfigured = false;
+if (typeof buildDirectSetting === "function" &&
+    (await yes("\nAlso serve anthropic/* models (OpenClaw's direct Anthropic route) from these accounts?", false))) {
+  const byId = new Map(accounts.map((a) => [a.id, a]));
+  const existingAccounts = existing?.plugins?.entries?.["multi-clawd"]?.config?.accounts ?? [];
+  for (const id of [...new Set([...accounts.map((a) => a.id), ...state.accountIds])]) {
+    const current = { ...(existingAccounts.find((a) => a?.id === id) ?? {}), ...(byId.get(id) ?? {}) };
+    if (current.direct !== undefined) {
+      console.log(`  ${id}: already has a direct-route setting — kept.`);
+      continue;
+    }
+    if (!(await yes(`  Add "${id}" to the direct route?`, true))) continue;
+    let setting;
+    if (canReuseCliTokenForDirect(current) && (await yes(`    reuse ${id}'s existing setup-token for it?`, true))) {
+      setting = buildDirectSetting(current, { kind: "reuse" });
+    } else {
+      const how = current.configDir
+        ? `CLAUDE_CONFIG_DIR=${current.configDir} claude setup-token`
+        : "claude setup-token";
+      console.log(`
+    ${id} needs a setup-token of its own for the direct route — its Claude login
+    is a rotating grant that multi-clawd never copies. In your own terminal, run:
+
+        ${how}
+
+    signed in as ${id}'s account (NOT your other one), and store the printed token:
+      1) in your secret manager (RECOMMENDED — OpenClaw stores only the reference)
+      2) in a token file (chmod 600)
+      3) it is ALREADY stored in OpenClaw as an anthropic profile (give its id)
+      4) skip ${id} for now`);
+      const choice = await ask("    choice (1/2/3/4):", "1");
+      try {
+        if (choice === "1") {
+          const provider = await ask("    gateway secret provider name:", "onepassword");
+          const refId = await ask("    secret reference (e.g. op://Vault/Item/field):");
+          if (refId) setting = buildDirectSetting(current, { kind: "ref", ref: { source: "exec", provider, id: refId } });
+        } else if (choice === "2") {
+          setting = buildDirectSetting(current, { kind: "file", path: await ask("    token file path:", `~/.${id}-direct-token`) });
+        } else if (choice === "3") {
+          const profileId = await ask("    existing profile id (see `openclaw models auth list --provider anthropic`):");
+          if (profileId.startsWith("anthropic:")) setting = { profileId };
+          else console.log("    ✗ profile ids for this route start with anthropic: — skipped");
+        }
+      } catch (err) {
+        console.log(`    ✗ ${err.message} — skipped`);
+      }
+    }
+    if (!setting) {
+      console.log(`    ${id}: not added.`);
+      continue;
+    }
+    const planned = byId.get(id);
+    if (planned) planned.direct = setting;
+    else accounts.push({ id, direct: setting });
+    directConfigured = true;
+    console.log(`    ✅ ${id} will serve anthropic/* as profile ${setting.profileId ?? `anthropic:${id}`}`);
+  }
+}
+
 // ── pool ─────────────────────────────────────────────────────────────────────
 const poolMemberIds = [...new Set([...accounts.map((a) => a.id), ...state.accountIds])];
 let pool;
@@ -400,6 +464,15 @@ if (DRY_RUN || !wroteConfig) {
 }
 
 // ── next steps ───────────────────────────────────────────────────────────────
+if (directConfigured) {
+  console.log(`
+Direct route: store the profiles in OpenClaw and set the order now with
+
+  multi-clawd direct sync
+
+(refs are stored as SecretRefs — the token is never copied; the gateway then
+keeps the anthropic order in pool-health order on its own).`);
+}
 console.log(`
 Done. Finish with: