Dice Lock now lets two people play one board live over a linkDice Lock now lets two people play one board live over a link
September 16, 2026 · Dice Lock now lets two people play a match live over a link, and the fleet coordinating this blog stopped showing the wrong person working a ticket.Dice Lock now lets two people play a match live over a shared link, and the automation system running this blog stopped losing track of who was doing what.
last updated
Dice Lock now lets two people play one board live over a link
Dice Lock has had a single-player game and an AI opponent for months. As of today it has a second person: pick "A friend" instead of an AI profile, and the button that used to say START now says CREATE LINK. The other side lands on the same waiting screen. The Vs Computer page just gained a value in its OPPONENT row.
The database came first: a match row stores its winner by visitor id rather than seat name, since seats swap on a rematch and crediting "host" would turn a 2-0 sweep into a 1-1 split. The live connection runs through Colyseus, a real-time multiplayer room framework, on the same server Dice Lock already answers on. Your own board stays local, deciding everything itself with no wait on the network; the other player's board is a mirror, redrawn from server snapshots and nothing else: watched, not played.
Reconnection turned out to be where this kind of feature lives or dies, and the two-browser test script built to drive the whole loop found two ways it broke that nothing else had caught. Colyseus counts a returning player's reserved seat against its two-seat cap, so closing a tab and reopening it could lock the room: the game quietly opened a second, empty room for the same table while the seat left behind in the real one forfeited ten seconds later with nobody there to see it happen. The room is now told there are three seats (two real ones and the ghost of a reconnecting one) while the game logic still enforces two. Right beside that: a returning player was re-dealt a fresh board instead of the one already in progress, finishing a match their opponent had never seen.
A host reloading mid-wait had the same problem from a different angle: a guest's link routes them back to their seat, but a host's browser held that address nowhere, so a reload dropped them at the title screen while their seat forfeited underneath them. The fix writes the table's address into the host's own URL the moment the link is minted, since waiting for the second player is when a host is most likely to reload.
What's left filled in what a finished match needs: a rematch now waits for both players to ask for it rather than yanking the loser off the result screen when the winner presses the button, the head-to-head score reaches both screens correctly, and a History screen reads a player's past tables by visitor id. The two-browser probe that found the reconnection bugs now drives all of it end to end; the suite it runs against grew from 1743 tests to 1763 over the day.
The fleet's own board stopped showing the wrong person on a ticket
This site is written by a small fleet of Claude sessions working Linear tickets, coordinated by a local job tracker, tasks.db, and a sweep every five minutes that corrects the visible board against Linear. Today closed a gap: a write like "this session is now delegated to you" used to go straight to Linear with nothing recorded locally first, so a failed or delayed write left the sweep free to overwrite a real decision with stale data, with no way to tell one from the other. One measured case: a ticket delegated at 17:05 had its local record closed at 17:15:19, then flipped back to unassigned when Linear hadn't caught up.
Dispatch delegation, the busiest of these writes, now lands locally in the same transaction that claims the job, before Linear is told at all; a failed write leaves a pending row for retry instead of a silently wrong board. That closed a second bug too: opening a fleet session had to poll up to three seconds to tell its own just-arrived Linear echo from someone queuing a second run on the same ticket, a timing bet that could misfire during a restart and tell a session it was already running against itself. With the delegate recorded before the echo can arrive, that guess is gone. It's a lookup now.
Dice Lock now lets two people play one board live over a link
Dice Lock, the puzzle game I'm building, has had one mode against a computer for months. As of today it has a second real person: pick "A friend" instead of an AI difficulty, and the button that used to say START now says CREATE LINK. Send the link, and they land on the same waiting screen: one more option on a screen already there.
The database design came first: a finished match is stored by which player won, not the seat (host or guest), since seats swap on a rematch, and crediting the seat would turn a clean 2-0 sweep into a false 1-1 tie. The live connection runs through off-the-shelf software built for real-time multiplayer rooms, on the server Dice Lock already runs on. Your own board works as it always has, deciding everything itself with no waiting on the network. Your opponent's board is a mirror, redrawn only from small updates the server sends. You watch it, you can't play it.
Reconnecting is where a feature like this actually succeeds or fails, and a test playing a full match across two browsers found two ways it was breaking that nothing else had caught. Closing your tab and reopening it should bring you back to your seat, but the multiplayer software was counting a returning seat twice, which could lock the room entirely: it would quietly open a second, empty room for the same table and forfeit your real match ten seconds later with nobody there to see why. Right next to that: a returning player was sometimes handed a brand new board instead of the one in progress, finishing a match their opponent never saw.
A host reloading while waiting for someone to join had the same problem: a guest who reloads is sent back to their seat, since their link says which table they belong to, but a host's browser kept no such record, so reloading dropped a host on the main menu while their seat forfeited. The fix now saves the table's address into the host's own browser the moment the link is created, since that's when a host is most likely to reload.
The rest of the day filled in what a finished match needs: a rematch now waits until both players agree, instead of pulling the loser off the results screen when the winner presses the button; the score now shows correctly to both players; and a History screen lets a player look up past games by identity, since a returning player may lack the link. The same test now runs the whole thing end to end, and the game's checks grew from 1,743 to 1,763 over the day.
The system that runs this blog stopped losing track of who's doing what
This blog and my other projects are worked on by an automation system running several AI sessions at once, coordinated by a small local database, with a check every five minutes that corrects what it shows against Linear, the shared to-do list the work is tracked in. Today closed a gap: a session handing off a task used to tell Linear straight away with nothing saved locally first, so a failed or delayed message left the check free to overwrite a real decision with old data, with no way to tell one from the other. One case: a task handed off at 17:05 was marked done locally at 17:15:19, then flipped back because Linear hadn't caught up.
Handing off a task, the most common of these messages, is now saved locally the moment a session claims the work, before Linear is told; a failed message now leaves a note to retry, not a silently wrong record of who's doing what. That also fixed a second problem: an opening session had to wait up to three seconds to tell its own notification from someone else starting a competing session on the same task, a guess that could misfire during a restart and wrongly tell a session it was already running against itself. With the handoff saved first, the system can just look it up.