A coding session cut off by its turn limit now finishes and commits the workAn AI assistant that runs out of turns now finishes the job instead of quitting
September 11, 2026 · A session cut off by its turn limit now wraps up and commits its own finished work, and a stranded branch gets a real command to land it safely.An AI helper cut off by its turn limit now finishes and saves its work, and a stuck piece of code gets a real, safe way to merge back in.
A session that hits its own turn limit now wraps up instead of leaving a mess
A ticket ran 163 tool calls today, finished the whole thing, and got stopped anyway: bigbrain-core's turn limit cut it off at 160, with 13 files sitting uncommitted and 951 tests passing. Because it never printed a result line, the fleet's retry planner filed it as an unreadable failure and left the finished work sitting in a worktree for a human to find. That was the one kind of failure nothing in the system knew how to answer, so today it got one: claudeRunner now resumes the same session by its own ID, gives it twelve more turns, and one instruction: stop working, run the test suite, commit what's green, and report what's left. A wrap-up that hits its own limit falls back to the old behavior instead of looping forever. It was tested by forcing the limit down to three tool calls and watching a session get cut off and come back finished, its cost tracked as one number instead of losing the resumed half.
A related gap closed the same day. When a task's branch outlives the process that was working it (a session dies, or is deliberately stopped), there's a check meant to refuse landing that branch onto the main line if its worktree is still being used by another live session. It turned out to have never actually fired: it compared the current folder to the worktree by name only, and the only way anyone runs the command is from a subfolder of it, which the comparison silently read as "nowhere." That was found by running the check from inside a real stranded worktree and watching it happily list that branch's own commits. It's now a proper path comparison, and it asks whether any other task is still running in that same worktree, not just whether the one row tied to this branch has finished. There's also, for the first time, an actual command for the half of a stranded-branch warning that used to only explain how to cancel one: restart:land rebases the branch, reruns its tests, and folds it in, with refusals built in for the ways getting this automatically wrong would move the main line on bad information.
Vs Computer loses its health bar; a match is now decided by a full board alone
dice-lock's Vs Computer mode has always had two ways to lose: run out of health, or top out with a stack that reaches the ceiling, the ending the whole game is designed around. An audit of 40 sample matches found the health pool was doing nearly all the deciding, 38 to 2. So health is gone. Damage still does everything it always did (it still charges the special-move meter, still counts toward the Endless score, still sends locked dice at the other board). It's just no longer subtracted from a pool that made the top-out mostly theoretical. The reroll delay went with it, since its zero setting had quietly stopped rewarding careful play, and match length is now one setting (3, 5, 10 minutes, or unlimited), picked on the opponent screen instead of buried in its own menu. Two AI numbers got corrected in the process: one difficulty's use of a move that only paid off against a nearly-dead opponent got repriced now that no one is ever nearly dead, and another weight turned out to have been rounding just under its intended threshold since an older ticket, traced to a fraction that comes out to 0.5499999999999999 in binary instead of 0.55.
A second change scaled the attack itself to match size: a three-of-a-kind used to send exactly as many locked dice at the opponent as a bigger match, and now it sends none on its own, while a four sends one and a five-or-bigger sends two. A three still does everything else a match does (damage, meter, unlocking a die it touches), because it's usually the only shape a board buried in locked dice can still build, and making it worse at digging out would have made a losing position unrecoverable.
An AI assistant that runs out of turns now finishes the job instead of quitting
BigBrain runs teams of AI coding assistants, called sessions, through a queue of tickets, and each one is only allowed a limited number of steps before it's cut off automatically. Today one session ran 163 of those steps, finished the ticket, and got cut off anyway right at its limit, with 13 files of working code never saved and 951 automated checks already passing. Because the cutoff happens mid-task, the system couldn't tell the work was done, so it filed it as broken and left the finished code untouched for a human to save by hand. That was the one kind of failure nothing in the system knew how to handle, so today it got a fix: the system now restarts that same assistant where it left off, gives it a short amount of extra time, and tells it one thing only: stop building, run the checks, save whatever works, and say what's left. If the restart itself runs out of time, the system falls back to the old behavior instead of trying forever. It was tested by setting the limit absurdly low and watching a session get cut off and come back finished, its cost tallied as one total instead of losing half.
A related problem got fixed the same day. Sometimes a ticket's work sits on its own branch because the assistant working it was stopped or crashed, and a safety check is meant to stop the system folding that branch into the main codebase while another assistant is still working in the same folder, which would destroy its unsaved work. That check had never actually worked: it compared folder locations in a way that failed for the only way anyone runs the command, letting the danger through. It was found by running it against a real leftover branch and watching it miss a live session working right there. It's fixed now, and it also checks for any other assistant working in that folder, not just the one tied to the ticket. And there's now a one-step command to fold a leftover branch back in safely: it updates the branch, reruns its tests, and merges it, refusing to act in several situations where doing it wrong would break the main codebase.
A dice game removes its health bar; a match is now decided by a filled board alone
Dice Lock is a puzzle game, and its computer-opponent mode has always had two ways to lose: run out of health, or fill your board to the top, the ending the game is designed around. A review of 40 sample matches found running out of health decided almost every one, 38 out of 40, while filling the board decided only 2. So health is gone. Landing an attack still does everything it did (charges your special-move meter, counts toward your score, sends locked dice onto the opponent's board). It just no longer drains a health number that was making the fill-the-board ending almost never happen. A delay meant to make rerolling risky also got removed, since it had quietly stopped doing that job, and match length is now one choice (3, 5, 10 minutes, or unlimited), picked on the same screen as choosing an opponent, not a separate settings screen. Two of the computer opponent's decision numbers also got corrected: one difficulty's use of a move that only paid off against an opponent close to losing on health got re-priced, since nobody loses that way anymore, and another number had been very slightly wrong since an older piece of work, traced to a rounding error in how computers store fractions.
A second change scaled attack size to match size. Matching three dice used to send as many locked dice at the opponent as a bigger match; now three alone send none, four send one, five or more send two. A three-match still does everything else it did (damage, meter, unlocking a die), because it's usually the only shape a buried board can still make, and weakening it further would leave a losing board with no way back.