@drakon-systems/multi-clawd 1.8.10 → 1.8.11

package/README.md

@@ -241,6 +241,11 @@ claude-cli/claude-fable-5        # main login
 - 🧲 **Sticky rotation (v0.3)** — after handing over, the pool dwells on the
   spare account (default 10 min) before returning home, so turns never flap
   across the threshold. Health always overrides stickiness.
+- 🔁 **In-turn retry on a reactive limit** — when an account hits a model cap
+  *during* a launch, the pool no longer loses that turn to the next provider in
+  your chain: the refusal is swallowed before anything reaches you and the turn
+  is re-spawned on a healthy account. Fresh launches, secret-free sibling
+  accounts, one retry.
 - 📟 **Operator alerts (v0.3)** — dead logins (probed every 15 min without
   spending quota), pool rotations, whole-pool exhaustion, and watchdog
   restarts surface through your agent's next heartbeat (e.g. straight into
@@ -369,7 +374,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.8.10/SETUP-AGENT.md
+> Read https://raw.githubusercontent.com/Drakon-Systems-Ltd/multi-clawd/v1.8.11/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/index.js

@@ -13,6 +13,7 @@ import { mergeHealthStates, parseStoredState, recordCredentialFailure, } from ".
 import { createTokenRefResolver, isSecretRefShape, } from "./token-resolution.js";
 import { resolveSecretRefValues } from "openclaw/plugin-sdk/secret-ref-runtime";
 import { resolvePoolExecutionArgs } from "./tool-cap.js";
+import { RETRY_ROSTER_ENV } from "./retry-plan.js";
 import { addAlert, alertKeysWithPrefix, clearAlert, pendingAlertText, } from "./alerts.js";
 import { healthStateFile, clearAccountCredentialFailure } from "./credential-state.js";
 export { healthStateFile, clearAccountCredentialFailure };
@@ -433,6 +434,21 @@ export function buildBackend(account, execMode) {
     Object.assign(backend.config, { sessionArg: "--session-id" });
     return backend;
 }
+export function buildRetryRoster(members, launchedId) {
+    const roster = [];
+    for (const member of members) {
+        if (member.id === launchedId)
+            continue;
+        if (member.oauthTokenFile || member.oauthTokenRef)
+            continue;
+        const stateFile = healthStateFile(member.id);
+        const env = buildAccountChildEnv(member, undefined, stateFile);
+        delete env.MULTI_CLAWD_ACCOUNT_ID;
+        delete env.MULTI_CLAWD_STATE_FILE;
+        roster.push({ id: member.id, stateFile, env });
+    }
+    return roster;
+}
 async function buildAccountEnv(account, resolver) {
     const token = await resolveTokenAsync(account, resolver);
     return buildAccountChildEnv(account, token, healthStateFile(account.id));
@@ -697,10 +713,12 @@ export function registerPoolBackend(api, pool, accounts, registeredIds, execMode
         writeStickyEntry(stickyFile, decision.sticky, logger);
         const order = [chosen, ...members.filter((m) => m.id !== chosen.id)];
         let env;
+        let launched;
         const unresolved = [];
         for (const candidate of order) {
             try {
                 env = await buildAccountEnv(candidate, deps?.resolver);
+                launched = candidate;
                 if (candidate.id !== chosen.id) {
                     logger.warn(`[multi-clawd] pool ${poolId}: ${chosen.id}'s credential did not resolve — ` +
                         `launching on ${candidate.id} instead (account not benched; secret provider may be down)`);
@@ -719,6 +737,11 @@ export function registerPoolBackend(api, pool, accounts, registeredIds, execMode
             throw new Error(`[multi-clawd] ${text}`);
         }
         alertState = clearAlert(alertState, `pool-unresolvable:${poolId}`);
+        {
+            const roster = buildRetryRoster(members, (launched ?? chosen).id);
+            if (roster.length > 0)
+                env[RETRY_ROSTER_ENV] = JSON.stringify(roster);
+        }
         if (ladder.length > 0) {
             const pinned = matchesPin(pins, {
                 agentDir: ctx.agentDir ?? "",

package/dist/models.js

@@ -1,5 +1,6 @@
 export const MODEL_ALIASES = {
     opus: "opus",
+    "opus-5.5": "claude-opus-5-5",
     "opus-5": "claude-opus-5",
     "opus-4.8": "claude-opus-4-8",
     "opus-4.7": "claude-opus-4-7",
@@ -9,6 +10,7 @@ export const MODEL_ALIASES = {
     haiku: "haiku",
 };
 const KNOWN_SPECS = {
+    "claude-opus-5-5": { name: "Claude Opus 5.5", contextWindow: 1000000, maxTokens: 128000 },
     "claude-opus-5": { name: "Claude Opus 5", contextWindow: 1000000, maxTokens: 128000 },
     "claude-opus-4-8": { name: "Claude Opus 4.8", contextWindow: 1048576, maxTokens: 128000 },
     "claude-opus-4-7": { name: "Claude Opus 4.7", contextWindow: 1048576, maxTokens: 64000 },

package/dist/retry-plan.js

@@ -0,0 +1,70 @@
+import { classifyAccountHealth } from "./health.js";
+export const RETRY_ROSTER_ENV = "MULTI_CLAWD_RETRY_ACCOUNTS";
+const CREDENTIAL_ENV_KEYS = ["CLAUDE_CONFIG_DIR", "CLAUDE_CODE_OAUTH_TOKEN"];
+export function parseRetryRoster(raw) {
+    if (!raw)
+        return [];
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch {
+        return [];
+    }
+    if (!Array.isArray(parsed))
+        return [];
+    const out = [];
+    for (const entry of parsed) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const e = entry;
+        if (typeof e.id !== "string" || !e.id)
+            continue;
+        if (typeof e.stateFile !== "string" || !e.stateFile)
+            continue;
+        const env = {};
+        if (e.env && typeof e.env === "object") {
+            for (const [k, v] of Object.entries(e.env)) {
+                if (typeof v === "string")
+                    env[k] = v;
+            }
+        }
+        out.push({ id: e.id, stateFile: e.stateFile, env });
+    }
+    return out;
+}
+export function retryArming(argv, roster) {
+    if (roster.length === 0) {
+        return { armed: false, reason: "no secret-free sibling account to retry onto" };
+    }
+    if (argv.includes("--resume")) {
+        return {
+            armed: false,
+            reason: "resumed session — its Claude session lives in this account's config dir",
+        };
+    }
+    if (!argv.some((a) => a === "stream-json" || a === "--output-format=stream-json")) {
+        return { armed: false, reason: "not a stream-json launch" };
+    }
+    return { armed: true };
+}
+export function chooseRetryAccount(params) {
+    for (const account of params.roster) {
+        const state = params.readState(account.stateFile);
+        const verdict = classifyAccountHealth(state, params.options ?? {}, params.nowMs, params.modelId).verdict;
+        if (verdict === "ok" || verdict === "no_data")
+            return account;
+    }
+    return undefined;
+}
+export function buildRetryEnv(base, account) {
+    const env = { ...base };
+    for (const key of CREDENTIAL_ENV_KEYS)
+        delete env[key];
+    for (const [k, v] of Object.entries(account.env))
+        env[k] = v;
+    env.MULTI_CLAWD_ACCOUNT_ID = account.id;
+    env.MULTI_CLAWD_STATE_FILE = account.stateFile;
+    env[RETRY_ROSTER_ENV] = "";
+    return env;
+}

package/dist/shim.js

@@ -5,6 +5,7 @@ import { classifyStateReadFailure, clearCredentialFailure, createLineScanner, me
 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";
 function resolveClaudeCommand() {
     const override = process.env.MULTI_CLAWD_CLAUDE_BIN;
     if (override) {
@@ -20,8 +21,8 @@ function resolveClaudeCommand() {
     }
     return { command: "claude", prependArgs: [] };
 }
-const stateFile = process.env.MULTI_CLAWD_STATE_FILE;
-const accountId = process.env.MULTI_CLAWD_ACCOUNT_ID ?? "unknown";
+let stateFile = process.env.MULTI_CLAWD_STATE_FILE;
+let accountId = process.env.MULTI_CLAWD_ACCOUNT_ID ?? "unknown";
 let state = { accountId, windows: {} };
 function preserveCorruptState(raw) {
     if (!stateFile)
@@ -87,11 +88,43 @@ if (modelOverride) {
         process.stderr.write(`[multi-clawd shim] degrading model for this launch → ${modelOverride}\n`);
     }
 }
-const child = spawn(command, childArgs, {
+const retryRoster = parseRetryRoster(process.env[RETRY_ROSTER_ENV]);
+const arming = retryArming(childArgs, retryRoster);
+let retryArmed = arming.armed;
+if (!retryArmed && retryRoster.length > 0 && arming.reason) {
+    process.stderr.write(`[multi-clawd shim] in-turn retry unavailable: ${arming.reason}\n`);
+}
+let child = spawn(command, childArgs, {
     stdio: ["pipe", "pipe", "inherit"],
     env: process.env,
 });
-process.stdin.pipe(child.stdin);
+const STDIN_REPLAY_CAP_BYTES = 8 * 1024 * 1024;
+let stdinReplay = [];
+let stdinReplayBytes = 0;
+let stdinEnded = false;
+if (retryArmed) {
+    process.stdin.on("data", (chunk) => {
+        if (retryArmed) {
+            stdinReplayBytes += chunk.length;
+            if (stdinReplayBytes > STDIN_REPLAY_CAP_BYTES) {
+                retryArmed = false;
+                stdinReplay = [];
+                releaseHeldOutput();
+            }
+            else {
+                stdinReplay.push(chunk);
+            }
+        }
+        child.stdin.write(chunk);
+    });
+    process.stdin.on("end", () => {
+        stdinEnded = true;
+        child.stdin.end();
+    });
+}
+else {
+    process.stdin.pipe(child.stdin);
+}
 function effectiveModelId() {
     const idx = childArgs.indexOf("--model");
     if (idx < 0 || idx + 1 >= childArgs.length)
@@ -109,7 +142,7 @@ function guessLimitResetsAt() {
     return undefined;
 }
 let sawAuthFailure = false;
-const scanner = createLineScanner((line) => {
+function observeLine(line) {
     try {
         const event = parseRateLimitEvent(line);
         if (event) {
@@ -135,12 +168,154 @@ const scanner = createLineScanner((line) => {
     }
     catch {
     }
-});
-child.stdout.on("data", (chunk) => {
+}
+const scanner = createLineScanner(observeLine);
+const HOLD_CAP_BYTES = 256 * 1024;
+const HOLD_MAX_MS = Number(process.env.MULTI_CLAWD_HOLD_MAX_MS ?? 10_000);
+let held = [];
+let heldBytes = 0;
+let holdTail = "";
+let retryUsed = false;
+function isPreambleRecord(line) {
+    if (line.length === 0)
+        return true;
+    try {
+        const record = JSON.parse(line);
+        if (record.type === "system" || record.type === "rate_limit_event")
+            return true;
+        if (record.type === "assistant" && record.message?.model === "<synthetic>")
+            return true;
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
+function releaseHeldOutput() {
+    if (held.length > 0) {
+        process.stdout.write(held.join(""));
+        held = [];
+        heldBytes = 0;
+    }
+    if (holdTail.length > 0) {
+        process.stdout.write(holdTail);
+        scanner.push(holdTail);
+        holdTail = "";
+    }
+    retryArmed = false;
+    stdinReplay = [];
+}
+function readSiblingState(file) {
+    try {
+        return parseStoredState(readFileSync(file, "utf8"));
+    }
+    catch {
+        return undefined;
+    }
+}
+function attemptRetry() {
+    if (!retryArmed || retryUsed)
+        return false;
+    const model = effectiveModelId();
+    const target = chooseRetryAccount({
+        roster: retryRoster,
+        readState: readSiblingState,
+        modelId: model,
+        nowMs: Date.now(),
+    });
+    if (!target) {
+        process.stderr.write(`[multi-clawd shim] model limit on ${accountId} with no healthy sibling to retry onto — ` +
+            `passing the failure through to the host's chain\n`);
+        releaseHeldOutput();
+        return false;
+    }
+    retryUsed = true;
+    retryArmed = false;
+    process.stderr.write(`[multi-clawd shim] model limit on ${accountId}${model ? ` for ${model}` : ""} — ` +
+        `retrying this turn on ${target.id} (nothing forwarded downstream yet)\n`);
+    held = [];
+    heldBytes = 0;
+    holdTail = "";
+    const previous = child;
+    previous.stdout.removeAllListeners();
+    previous.removeAllListeners("close");
+    previous.removeAllListeners("error");
+    try {
+        previous.kill("SIGTERM");
+    }
+    catch {
+    }
+    accountId = target.id;
+    stateFile = target.stateFile;
+    state = { accountId, windows: {} };
+    sawAuthFailure = false;
+    child = spawn(command, childArgs, {
+        stdio: ["pipe", "pipe", "inherit"],
+        env: buildRetryEnv(process.env, target),
+    });
+    attachChildHandlers();
+    for (const chunk of stdinReplay)
+        child.stdin.write(chunk);
+    if (stdinEnded)
+        child.stdin.end();
+    stdinReplay = [];
+    return true;
+}
+function onArmedChunk(chunk) {
+    holdTail += chunk.toString("utf8");
+    while (retryArmed) {
+        const idx = holdTail.indexOf("\n");
+        if (idx < 0)
+            break;
+        const raw = holdTail.slice(0, idx + 1);
+        holdTail = holdTail.slice(idx + 1);
+        const line = raw.trim();
+        observeLine(line);
+        if (parseModelLimitError(line) && attemptRetry())
+            return;
+        held.push(raw);
+        heldBytes += raw.length;
+        if (!isPreambleRecord(line) || heldBytes > HOLD_CAP_BYTES) {
+            releaseHeldOutput();
+            return;
+        }
+    }
+    if (!retryArmed && holdTail.length > 0) {
+        const rest = holdTail;
+        holdTail = "";
+        process.stdout.write(rest);
+        scanner.push(rest);
+    }
+}
+if (retryArmed) {
+    const holdTimer = setTimeout(() => {
+        if (!retryArmed)
+            return;
+        process.stderr.write(`[multi-clawd shim] in-turn retry window closed after ${HOLD_MAX_MS}ms — releasing the stream\n`);
+        releaseHeldOutput();
+    }, HOLD_MAX_MS);
+    holdTimer.unref?.();
+}
+function onPassthroughChunk(chunk) {
     process.stdout.write(chunk);
     scanner.push(chunk.toString("utf8"));
-});
-child.stdout.on("end", () => scanner.flush());
+}
+function attachChildHandlers() {
+    const armedForThisChild = retryArmed;
+    child.stdout.on("data", (chunk) => {
+        if (armedForThisChild && retryArmed)
+            onArmedChunk(chunk);
+        else
+            onPassthroughChunk(chunk);
+    });
+    child.stdout.on("end", () => {
+        if (retryArmed)
+            releaseHeldOutput();
+        scanner.flush();
+    });
+    child.on("close", onChildClose);
+    child.on("error", onChildError);
+}
 for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) {
     process.on(signal, () => {
         child.kill(signal);
@@ -159,7 +334,7 @@ function clearRecordedAuthFailureOnSuccess() {
     catch {
     }
 }
-child.on("close", (code, signal) => {
+function onChildClose(code, signal) {
     if (signal) {
         process.kill(process.pid, signal);
         return;
@@ -167,8 +342,9 @@ child.on("close", (code, signal) => {
     if ((code ?? 0) === 0)
         clearRecordedAuthFailureOnSuccess();
     process.exit(code ?? 0);
-});
-child.on("error", (err) => {
+}
+function onChildError(err) {
     process.stderr.write(`[multi-clawd shim] failed to spawn claude: ${String(err)}\n`);
     process.exit(127);
-});
+}
+attachChildHandlers();

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "multi-clawd",
   "name": "multi-clawd",
-  "version": "1.8.10",
+  "version": "1.8.11",
   "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.8.10",
+  "version": "1.8.11",
   "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",