feat: honest AI opponent in quick game

New Game's quick game gains an explicit opponent selector — 🤖 AI (default)
or 👤 Random player. AI starts a game seated with a pooled robot that joins
and moves at once: no per-move timeout (a 7-day inactivity loss reusing the
turn-timeout sweeper), chat/nudge disabled, no statistics, the opponent shown
as 🤖 everywhere. The random path (disguised robot) is unchanged.

Driven by one game flag (games.vs_ai), set only on AI-started games so the
disguised path is never revealed; Matchmaker.StartVsAI seats the robot
directly (no open pool); the robot replies event-driven via the game service's
after-commit/after-create hook. Wire: vs_ai on EnqueueRequest + GameView.

backend/internal/server/dto.go

@@ -94,8 +94,11 @@ type gameDTO struct {
 	ToMove               int    `json:"to_move"`
 	TurnTimeoutSecs      int    `json:"turn_timeout_secs"`
 	MultipleWordsPerTurn bool   `json:"multiple_words_per_turn"`
-	MoveCount            int    `json:"move_count"`
-	EndReason            string `json:"end_reason"`
+	// VsAI marks an honest-AI game: the opponent is shown as 🤖 and chat/nudge/add-friend
+	// are suppressed in the client.
+	VsAI      bool   `json:"vs_ai"`
+	MoveCount int    `json:"move_count"`
+	EndReason string `json:"end_reason"`
 	// LastActivityUnix is the lobby sort key: the current turn's start for an active
 	// game, the finish time once finished.
 	LastActivityUnix int64     `json:"last_activity_unix"`
@@ -220,6 +223,7 @@ func gameDTOFromGame(g game.Game) gameDTO {
 		ToMove:               g.ToMove,
 		TurnTimeoutSecs:      int(g.TurnTimeout.Seconds()),
 		MultipleWordsPerTurn: g.MultipleWordsPerTurn,
+		VsAI:                 g.VsAI,
 		MoveCount:            g.MoveCount,
 		EndReason:            g.EndReason,
 		LastActivityUnix:     last.Unix(),

backend/internal/server/handlers.go

@@ -168,6 +168,8 @@ func statusForError(err error) (int, string) {
 		return http.StatusConflict, "nudge_own_turn"
 	case errors.Is(err, game.ErrFinished), errors.Is(err, social.ErrGameNotActive):
 		return http.StatusConflict, "game_finished"
+	case errors.Is(err, social.ErrGameVsAI):
+		return http.StatusConflict, "ai_game"
 	case errors.Is(err, game.ErrNoOpponentYet):
 		return http.StatusConflict, "no_opponent_yet"
 	case errors.Is(err, game.ErrGameActive):

backend/internal/server/handlers_user.go

@@ -133,15 +133,18 @@ func (s *Server) handleGameState(c *gin.Context) {
 	c.JSON(http.StatusOK, dto)
 }
 
-// enqueueRequest enters per-variant auto-match under a per-turn word rule.
+// enqueueRequest enters per-variant auto-match under a per-turn word rule. VsAI true
+// starts an honest-AI game against a robot instead of the open/wait matchmaking path.
 type enqueueRequest struct {
 	Variant              string `json:"variant"`
 	MultipleWordsPerTurn bool   `json:"multiple_words_per_turn"`
+	VsAI                 bool   `json:"vs_ai"`
 }
 
-// handleEnqueue enters the caller into auto-match for a variant and returns the game
-// they land in immediately: a freshly opened game awaiting an opponent, or another
-// player's open game they just joined. The client navigates straight into the game.
+// handleEnqueue enters the caller into a quick game and returns the game they land in
+// immediately. With vs_ai it starts an honest-AI game already seated with a robot;
+// otherwise it enters auto-match — a freshly opened game awaiting an opponent, or
+// another player's open game they just joined. The client navigates straight in.
 func (s *Server) handleEnqueue(c *gin.Context) {
 	uid, ok := userID(c)
 	if !ok {
@@ -158,7 +161,11 @@ func (s *Server) handleEnqueue(c *gin.Context) {
 		abortBadRequest(c, "unknown variant")
 		return
 	}
-	res, err := s.matchmaker.Enqueue(c.Request.Context(), uid, variant, req.MultipleWordsPerTurn)
+	enter := s.matchmaker.Enqueue
+	if req.VsAI {
+		enter = s.matchmaker.StartVsAI
+	}
+	res, err := enter(c.Request.Context(), uid, variant, req.MultipleWordsPerTurn)
 	if err != nil {
 		s.abortErr(c, err)
 		return