feat(lobby): enter the game immediately and wait for the opponent inside it

Quick auto-match no longer waits on a separate screen: Enqueue opens a real game seating the caller with an empty opponent seat (new game status 'open') and the player enters it at once. A second human searching the same variant+rule joins that open game; otherwise a background reaper seats a robot after a 90s + random 0-90s wait, pushing a new in-app opponent_joined event that fills the opponent card and re-enables resign and chat in place.

Matchmaking state is now the open games in the database (the in-memory pool, lobby.poll and lobby.cancel are gone), serialised by a per-bucket advisory lock. While a game is open the starter may move on their turn, but resign, chat and nudge are refused; the lobby and opponent card show "searching for opponent".

Schema edited in the baseline (no prod data): 'open' status, nullable game_players.account_id for the empty seat, and a games.open_deadline_at stamp; jet code regenerated.

backend/internal/game/service.go

@@ -145,6 +145,96 @@ func (svc *Service) Create(ctx context.Context, params CreateParams) (Game, erro
 	return svc.store.GetGame(ctx, id)
 }
 
+// OpenOrJoin enters accountID into auto-match for the variant and per-turn rule in
+// params and returns the game they land in immediately: another waiting player's open
+// game (joined=true), the caller's own still-open game on a re-enqueue, or a fresh open
+// game seating only the caller with an empty opponent seat that a human or the reaper's
+// robot fills later. openDeadline is when the reaper substitutes a robot into a freshly
+// opened game (ignored when joining one). The bag seed defaults to random; params.Seed
+// pins it. First-move fairness comes from seating the caller at seat 0 or seat 1
+// (derived from the seed): seated at seat 1, the still-empty seat 0 moves first, so the
+// caller just waits for the opponent. It backs the lobby auto-match enqueue.
+func (svc *Service) OpenOrJoin(ctx context.Context, accountID uuid.UUID, params CreateParams, openDeadline time.Time) (Game, bool, error) {
+	if _, err := svc.accounts.GetByID(ctx, accountID); err != nil {
+		if errors.Is(err, account.ErrNotFound) {
+			return Game{}, false, fmt.Errorf("%w: account %s not found", ErrInvalidConfig, accountID)
+		}
+		return Game{}, false, err
+	}
+	timeout := params.TurnTimeout
+	if timeout == 0 {
+		timeout = DefaultTurnTimeout
+	}
+	if !allowedTimeout(timeout) {
+		return Game{}, false, fmt.Errorf("%w: turn timeout %s not allowed", ErrInvalidConfig, timeout)
+	}
+	id, err := uuid.NewV7()
+	if err != nil {
+		return Game{}, false, fmt.Errorf("game: new id: %w", err)
+	}
+	seed := params.Seed
+	if seed == 0 {
+		seed = svc.rng()
+	}
+	deadline := openDeadline
+	ins := gameInsert{
+		id:                   id,
+		variant:              params.Variant.String(),
+		dictVersion:          svc.version,
+		seed:                 seed,
+		players:              2,
+		turnTimeoutSecs:      int(timeout / time.Second),
+		hintsAllowed:         params.HintsAllowed,
+		hintsPerPlayer:       params.HintsPerPlayer,
+		dropoutTiles:         params.DropoutTiles.String(),
+		multipleWordsPerTurn: params.MultipleWordsPerTurn,
+		status:               StatusOpen,
+		openDeadline:         &deadline,
+	}
+	// Seat the caller at seat 0 or seat 1 (seat 0 always moves first); the other seat
+	// is left empty (uuid.Nil) for the opponent.
+	seats := []uuid.UUID{accountID, uuid.Nil}
+	if seed&1 == 1 {
+		seats = []uuid.UUID{uuid.Nil, accountID}
+	}
+	gameID, joined, created, err := svc.store.OpenOrJoin(ctx, accountID, ins, seats)
+	if err != nil {
+		return Game{}, false, err
+	}
+	if created {
+		svc.metrics.recordStarted(ctx, params.Variant)
+	}
+	g, err := svc.store.GetGame(ctx, gameID)
+	if err != nil {
+		return Game{}, false, err
+	}
+	return g, joined, nil
+}
+
+// AttachRobot seats robotID in the empty opponent seat of open game gameID and flips
+// it to active, returning the now-active game and whether it attached (false, with a
+// zero Game, when a human joined first). It backs the matchmaking reaper.
+func (svc *Service) AttachRobot(ctx context.Context, gameID, robotID uuid.UUID) (Game, bool, error) {
+	attached, err := svc.store.AttachRobot(ctx, gameID, robotID)
+	if err != nil {
+		return Game{}, false, err
+	}
+	if !attached {
+		return Game{}, false, nil
+	}
+	g, err := svc.store.GetGame(ctx, gameID)
+	if err != nil {
+		return Game{}, false, err
+	}
+	return g, true, nil
+}
+
+// ExpiredOpen returns the open games due for a robot substitution (deadline at or
+// before now) for the matchmaking reaper.
+func (svc *Service) ExpiredOpen(ctx context.Context, now time.Time) ([]OpenGame, error) {
+	return svc.store.ExpiredOpen(ctx, now)
+}
+
 // engineOp applies one transition to the live game, returning the decoded record
 // and, for an exchange, the swapped tiles.
 type engineOp func(g *engine.Game) (engine.MoveRecord, []string, error)
@@ -189,6 +279,11 @@ func (svc *Service) Resign(ctx context.Context, gameID, accountID uuid.UUID) (Mo
 	if !ok {
 		return MoveResult{}, ErrNotAPlayer
 	}
+	// Resign needs a present opponent to award the win, so it is refused while the game
+	// is still waiting for one; the UI keeps the button disabled until then.
+	if pre.Status == StatusOpen {
+		return MoveResult{}, ErrNoOpponentYet
+	}
 	if pre.Status != StatusActive {
 		return MoveResult{}, ErrFinished
 	}
@@ -260,7 +355,10 @@ func (svc *Service) transition(ctx context.Context, gameID, accountID uuid.UUID,
 	if !ok {
 		return MoveResult{}, ErrNotAPlayer
 	}
-	if pre.Status != StatusActive {
+	// A move is allowed while the game is active or still open (the starter may move on
+	// their turn before an opponent joins); only a finished game rejects it. The turn
+	// check below keeps the starter off the still-empty opponent seat.
+	if pre.Status == StatusFinished {
 		return MoveResult{}, ErrFinished
 	}
 	if pre.ToMove != seat {
@@ -382,6 +480,9 @@ func (svc *Service) emitMove(ctx context.Context, post Game, rec engine.MoveReco
 	summary := gameSummary(post, names)
 	intents := make([]notify.Intent, 0, 2*len(post.Seats))
 	for _, s := range post.Seats {
+		if s.AccountID == uuid.Nil {
+			continue // an open game's opponent seat is not yet filled — nobody to notify
+		}
 		intents = append(intents, notify.OpponentMoved(s.AccountID, post.ID, rec, summary, bagLen))
 	}
 	// Game pushes are routed out-of-app by the game's own language, not the recipient's
@@ -406,6 +507,9 @@ func (svc *Service) emitMove(ctx context.Context, post Game, rec engine.MoveReco
 		// seat, each with their own perspective + recipient-first score, so an offline player gets
 		// an out-of-app "game over" push (online players take it from the in-app refresh).
 		for _, s := range post.Seats {
+			if s.AccountID == uuid.Nil {
+				continue
+			}
 			over := notify.GameOver(s.AccountID, post.ID, seatResult(post.Seats, s.Seat), scoreLine(post, s.Seat), summary)
 			over.Language = lang
 			intents = append(intents, over)
@@ -540,7 +644,7 @@ func (svc *Service) EvaluatePlay(ctx context.Context, gameID, accountID uuid.UUI
 	if _, ok := pre.seatOf(accountID); !ok {
 		return EvalResult{}, ErrNotAPlayer
 	}
-	if pre.Status != StatusActive {
+	if pre.Status == StatusFinished {
 		return EvalResult{}, ErrFinished
 	}
 
@@ -674,7 +778,7 @@ func (svc *Service) Hint(ctx context.Context, gameID, accountID uuid.UUID) (Hint
 	if !ok {
 		return HintResult{}, ErrNotAPlayer
 	}
-	if pre.Status != StatusActive {
+	if pre.Status == StatusFinished {
 		return HintResult{}, ErrFinished
 	}
 	if pre.ToMove != seat {
@@ -736,7 +840,7 @@ func (svc *Service) Candidates(ctx context.Context, gameID, accountID uuid.UUID)
 	if !ok {
 		return nil, ErrNotAPlayer
 	}
-	if pre.Status != StatusActive {
+	if pre.Status == StatusFinished {
 		return nil, ErrFinished
 	}
 	if pre.ToMove != seat {