Rotating to a backup Claude account now actually happensSwitching to a backup Claude account now actually happens when needed
September 13, 2026 · The budget gate now actually checks a backup Claude account, keeps its permissions when it switches to one, and gives a still-working session more time instead of killing it early.My automation now actually switches to a backup Claude account when needed, keeps that account working properly, and gives real work more time instead of cutting it short.
Rotating to a backup Claude account now actually happens
BigBrain has been able to name a backup Claude account for a while, but the budget gate that decides whether to use one only ever checked usage on the default account. budgetGate.refresh() never named a second account, so no backup could clear the exact-and-recent bar a reading needs, and every run fell through to the plain fallback, byte-identical to having no backup configured at all, regardless of how many were set up. Today's fix has the refresh probe the default account and then every credentialed named account, in one cycle, before it applies the default reading's halt and warn decisions. When the default account crosses a line, chooseAccount() can now see a backup's fresh reading and rotate into it immediately instead of falling through. The probe also stopped reading Claude's own login credential to do this: a new usage broker asks Claude Code's own status-line interface for the same rate-limit numbers, so the gate can read usage on an account without ever holding that account's OAuth token itself.
Getting probing right surfaced a second bug on the first real run against a live backup account: it started, and refused to edit, write, or even touch a file in a worktree it had itself been told was fine to modify. A rotated session sets CLAUDE_CONFIG_DIR to the backup account's own isolated settings directory, and Claude Code reads its permission mode from that same directory. So switching accounts had been silently switching the session back to asking-for-approval mode, which nobody is there to answer on an unattended box. The repository's own grant to edit and run commands there was never in question; only the account happened to change which settings file supplied the mode. The fix spells the already-validated permission mode explicitly on the command line for every unattended session, so which account is paying for the run can no longer change what it's allowed to do.
The same day's work also closed a gap the rotation testing ran into directly: a session doing real work can still get killed by its own wall-clock limit before it's done. One delivery session hit its one-hour wall with 11 files changed, 841 lines inserted, and real progress on the task, but its last five tool calls all looked like Bash to the code watching for stuck loops, so it got killed mid-work; the final result never got written, and the ticket came back as an unreadable failure even though the answer was sitting in the worktree. The wall is now a checkpoint instead of a kill switch: at that point the runner checks for real evidence a session is still moving (a dirty tree with recent edits, a new commit, distinct completed test or check calls) and grants a 15-minute extension if it finds any, repeating at each boundary up to four times, so a delivery session can now run for up to two hours instead of stopping flat at one. A session that still looks stuck, by contrast, gets the same one bounded resume pass introduced earlier this month: no new investigation, one test run, commit only if it's green.
Switching to a backup Claude account now actually happens when needed
My automation, BigBrain, can be set up with a backup Claude account for when the main one runs low on usage, but the safety check that decides when to switch never actually looked at the backup account's usage, only the main one's. So even with a backup configured, the system always fell back to a generic default behavior instead, no different from having no backup at all. Today's fix makes that check look at the main account and then every backup account, in one pass, before deciding whether to warn or stop. When the main account's usage crosses a line, the system can now see that a backup has room and switch to it right away. The way it checks usage changed too: instead of needing to read the account's private login information directly, it now asks Claude's own built-in status display for the same numbers, so the system never has to hold onto an account's login credentials just to check how much it's used.
Getting that check working uncovered a second problem, on the very first real run against a live backup account: the session started up and then refused to edit files, write files, or even create a new empty file in a project folder it had already been told it was allowed to work in. Switching accounts also switches which settings folder Claude reads its permission settings from, and it turned out that folder controls whether a session can act without asking for approval first. So switching to the backup account was quietly switching the session back into "ask before doing anything" mode, which is a problem when nobody is sitting there to answer, since these sessions run unattended. The project's own permission to let an agent work there hadn't changed; only the account paying for the session had, and that was enough to flip the setting. The fix now sets that permission explicitly every time an unattended session starts, so which account is running the session can no longer change what it's allowed to do.
The same day's work also fixed a related problem that testing this ran into directly: a session that's genuinely still working can get shut down just because it hit a time limit. One session had spent an hour making real changes (11 files edited, 841 lines added), but its last several actions all looked the same to the code watching for a stuck loop, so it got killed in the middle of the work; it never got to report what it had done, and the task came back logged as a failure even though the finished work was sitting right there. The time limit is now a checkpoint instead of an automatic cutoff: when a session reaches it, the system checks for real signs the session is still making progress (recently edited files, a new save to the project's history, distinct test results), and if it finds any, grants 15 more minutes. That can repeat up to four times, so a session doing real work can now run for up to two hours instead of stopping flat at one. A session that genuinely looks stuck still gets one chance to wrap up cleanly: no new work, one test run, and it only saves its changes if that test run passes.