A thirty-turn warning stops a session from starting work it cannot finishA warning before a worker runs out of time stops it starting something it can't finish

October 5, 2026 · A session now hears it is thirty turns from its turn limit, before it starts work it can't land, and dice-lock's Tower climb reaches twenty-five floors.One of my workers now hears it's running low on time before it starts something it can't finish, and my dice game's tower climb reaches twenty-five floors.
last updated

A session now hears it is thirty turns from running out

Until today a session had no way to know it was about to hit its turn limit. JIO-1663 landed its whole ticket in two clean commits, then started rewriting a probe nobody had asked for with twenty-five turns left on its 160-turn ceiling, and got cut off mid-edit with the typecheck one over its own limit. The wrap-up prompt that runs at a ceiling isn't allowed to fix anything, so the suite stayed red and the branch never reached main. That wasn't a one-off: of the 93 sessions that hit a turn ceiling between 2026-08-26 and 2026-10-05, 20 ended with a red tree.

A session can't count its own turns, and nothing the task runner writes reaches a running session once it has started. A hook can, though. Every session now carries one that counts its tool calls and says, once, thirty turns out: start nothing new, close what's open, commit it, and don't stop early just because of this notice. That last part matters, because a session that finishes early for its own reasons hasn't hit a ceiling and shouldn't act like it has. Checked against the real CLI rather than its documentation: the notice reaches the model, a subagent's own calls don't trigger it, and a session given a twelve-turn ceiling with the notice set at three got told once and still made all five calls it was asked for.

A second gap sat right next to it. A session that still hit a red ceiling, tree dirty, one file failing, used to be refused a continuation unless its report also named exactly what was left undone, the same bar a clean, green ceiling has to clear. Two tickets sat stuck on their owner that way, the fix one sentence of prose away each time. Of the seven red ceilings blamed on the session itself since that field existed, the five that happened to name what was left got continued and all five landed; the gate cost the other two and protected nothing. A red ceiling is now continued on the dirty tree and the session's own diagnosis alone, and the brief handed to the next session lists whatever commits already landed instead of wrongly claiming nothing had.

dice-lock's Tower reaches twenty-five floors, and the phone app's games finally reach the server

dice-lock's Tower, the long-form mode where every floor is a themed board guarded by a boss with its own rule, grew from seventeen floors to twenty-five, and each new one adds a mechanic instead of repeating an old one harder: dice frozen in ice until struck twice, a hall of mirrors hiding what a die shows, a fuse burning down a die's value, a volley that grows every turn, a casino floor that can force a reshuffle, and a Transmute that turns a die into whatever face the board shows most. The difficulty curve for those nine new floors is marked provisional, set by hand at 70% of the usual formula, because the simulator that normally tunes difficulty can't yet play a board with locked, hidden, or fusing dice. The build shipped to TestFlight as build 14.

Separately: not one play event from the iPhone app had ever reached the server. Six people had signed in to test it, one of them active that very day, and the count behind all of them was zero. The cause was a browser mechanism built to survive a page closing mid-request, sending a JSON batch to a different server address, which needs a security check first. WebKit ran that check, got the go-ahead, and never sent the actual data, and still reported the send as successful, so the queue marked every batch delivered and threw it away. Switching that one send to a plain request fixed it, confirmed by re-running it in a simulator and watching the data land this time. The fix reaches phones with the next TestFlight build.

One of my workers now hears it's running low on time, before it starts something new

I hand tickets of work to sessions: short-lived AI workers, each given a turn limit on how many steps before it has to stop. Until today a worker had no way to know it was close to that limit. One worker finished its job in two clean pieces, then started rewriting something nobody had asked it to touch, with only twenty-five steps left before its limit of 160. It got cut off partway through, a check still failing, nothing to clean it up, so the batch stayed broken and never reached the main codebase. That wasn't a one-off: of the 93 workers that hit their step limit between 2026-08-26 and 2026-10-05, 20 left things broken behind them.

A worker can't count its own steps, and once running, nothing I write afterward reaches it. A small watcher that fires on every action can. Every worker now carries one, and it speaks up once, thirty steps before the limit: stop starting anything new, finish and save whatever is open, and don't stop early just because of this warning. That matters, because a worker that finishes early for its own reasons hasn't hit the limit and shouldn't act as if it has. Tested against the real tool rather than its documentation: the warning reaches the worker, a helper it spins up doesn't wrongly get it too, and a worker given a twelve-step limit with the warning three steps out got told once and still finished everything asked.

A second gap sat next to that one. A worker that still hit its limit while leaving something broken, half-saved work, one check failing, used to be refused a second attempt unless its report spelled out exactly what was left, the same standard a worker that finished cleanly had to meet. Two pieces of work got stuck waiting on a human that way, when the fix was one sentence away each time. Looking at every worker that blamed itself for a broken result, the ones that described what was left got a second attempt and all finished; the stricter rule cost the other two nothing but delay. A second attempt now rests on the broken state and the worker's own explanation alone, and the next worker picking up the job is told what already succeeded, not wrongly told nothing had.

My dice game's tower climb reaches twenty-five floors, and the phone app's games finally reach the server

One of the games I run, dice-lock, has a long-form mode called the Tower: climb floor by floor, each a themed puzzle board guarded by a boss with its own twist. That climb grew from seventeen floors to twenty-five, and each new floor adds something it hasn't tried before rather than making an old trick harder: dice frozen in ice until struck twice, a hall of mirrors hiding what a die shows, a fuse burning down a die's value, an attack that grows every turn, a casino floor that can force a reshuffle, and a floor that turns a die into whatever face shows up most. The tool I use to judge how hard a floor should be can't yet play boards with these new tricks, so those nine floors have their difficulty set by hand, a bit easier than the formula would land them. The update reached early testers as build 14.

Separately: the iPhone version of the game had never once sent its play data back to the server. Six people had signed in to test it, one active that day, and the count behind every one was zero. The cause was a method for sending data built to survive the app closing mid-request, aimed at a different server address, which requires a security check first. The phone's browser engine ran that check, got the go-ahead, and never sent the data, while telling the game it had succeeded, so the data was thrown away every time. Switching to a more reliable way of sending the request fixed it, confirmed by testing again and watching the data arrive. The fix reaches phones with the next test version of the app.