fix(social): robot blocks

Blocking an auto-match opponent who is secretly a pooled robot is recorded  instead in a separate `robot_blocks` table.

Now blocking behaves the same in that game (struck name, hidden composer) and lists the blocked opponent under the name you saw, but is recorded only against that game — the disguise holds, the shared robot is never globally blocked, and the matchmaker keeps pairing you with robots (so you can never block yourself out of opponents).

- the shared robot account is never put in `blocks`
- the matchmaker keeps it free and it is not blocked under its other per-game names
- the blocked list and the in-game card still show it by joining that table; an unblock deletes the row

backend/internal/social/blocks.go

@@ -35,15 +35,23 @@ func (svc *Service) Block(ctx context.Context, blockerID, blockedID uuid.UUID) e
 	return nil
 }
 
-// Unblock removes blockerID's block on blockedID and confirms it to the (former)
-// blocker with a user_unblocked event so their open game screens restore the controls
-// and un-strike the name in place. Any friendship the block had been overriding becomes
-// effective again. It is idempotent.
-func (svc *Service) Unblock(ctx context.Context, blockerID, blockedID uuid.UUID) error {
-	if err := svc.store.deleteBlock(ctx, blockerID, blockedID); err != nil {
+// Unblock removes blockerID's block on the given target and confirms it to the (former)
+// blocker with a user_unblocked event so their open game screens restore the controls and
+// un-strike the name in place. The target is either a blocked human's account id (the
+// blocks table) or a robot_blocks row id (a per-game disguised-robot block) — the robot
+// block is tried first, falling back to the human block. Any friendship the block had been
+// overriding becomes effective again. It is idempotent.
+func (svc *Service) Unblock(ctx context.Context, blockerID, target uuid.UUID) error {
+	removed, err := svc.store.deleteRobotBlock(ctx, blockerID, target)
+	if err != nil {
 		return err
 	}
-	svc.pub.Publish(notify.NotificationAccount(blockerID, notify.NotifyUserUnblocked, svc.accountRef(ctx, blockedID)))
+	if !removed {
+		if err := svc.store.deleteBlock(ctx, blockerID, target); err != nil {
+			return err
+		}
+	}
+	svc.pub.Publish(notify.NotificationAccount(blockerID, notify.NotifyUserUnblocked, svc.accountRef(ctx, target)))
 	return nil
 }
 

backend/internal/social/robotblocks.go

@@ -0,0 +1,115 @@
+package social
+
+import (
+	"context"
+	"fmt"
+	"slices"
+
+	"github.com/google/uuid"
+
+	"scrabble/backend/internal/notify"
+)
+
+// RobotBlock is one per-game block of a disguised-robot opponent: the row id (used to
+// unblock it), the game name the player saw, and the game + seat it was blocked in.
+type RobotBlock struct {
+	ID          uuid.UUID
+	DisplayName string
+	GameID      uuid.UUID
+	Seat        int
+}
+
+// BlockInGame blocks blockedID for blockerID from within gameID. A human is blocked
+// normally (the blocks table, via Block). A disguised-robot opponent is instead recorded
+// per-game in robot_blocks — never the shared robot account — so the matchmaker keeps
+// robots free and the same robot stays unblocked in the blocker's other games (under its
+// other names); the row snapshots the seat and the name the player saw so the blocked list
+// and the in-game card can show it. It is the entry point for the in-game block control;
+// the settings-screen block (no game) goes through Block directly.
+func (svc *Service) BlockInGame(ctx context.Context, blockerID, blockedID, gameID uuid.UUID) error {
+	if blockerID == blockedID {
+		return ErrSelfRelation
+	}
+	isRobot, err := svc.accounts.IsRobot(ctx, blockedID)
+	if err != nil {
+		return err
+	}
+	if !isRobot {
+		return svc.Block(ctx, blockerID, blockedID)
+	}
+	if gameID == uuid.Nil {
+		return ErrNotParticipant
+	}
+	seats, _, _, err := svc.games.Participants(ctx, gameID)
+	if err != nil {
+		return err
+	}
+	seat := slices.Index(seats, blockedID)
+	if seat < 0 {
+		return ErrNotParticipant
+	}
+	name, _ := svc.games.SeatName(ctx, gameID, blockedID)
+	if err := svc.store.insertRobotBlock(ctx, blockerID, gameID, seat, blockedID, name); err != nil {
+		return err
+	}
+	svc.pub.Publish(notify.NotificationAccount(blockerID, notify.NotifyUserBlocked, svc.accountRef(ctx, blockedID)))
+	return nil
+}
+
+// ListRobotBlocks returns blockerID's per-game disguised-robot blocks, newest first.
+func (svc *Service) ListRobotBlocks(ctx context.Context, blockerID uuid.UUID) ([]RobotBlock, error) {
+	return svc.store.listRobotBlocks(ctx, blockerID)
+}
+
+// insertRobotBlock records a per-game robot block; a duplicate (same blocker, game, seat)
+// is ignored.
+func (s *Store) insertRobotBlock(ctx context.Context, blocker, gameID uuid.UUID, seat int, robotID uuid.UUID, name string) error {
+	id, err := uuid.NewV7()
+	if err != nil {
+		return fmt.Errorf("social: new robot block id: %w", err)
+	}
+	const q = `INSERT INTO backend.robot_blocks (id, blocker_id, game_id, seat, robot_id, display_name)
+VALUES ($1, $2, $3, $4, $5, $6)
+ON CONFLICT (blocker_id, game_id, seat) DO NOTHING`
+	if _, err := s.db.ExecContext(ctx, q, id, blocker, gameID, int16(seat), robotID, name); err != nil {
+		return fmt.Errorf("social: insert robot block: %w", err)
+	}
+	return nil
+}
+
+// deleteRobotBlock removes blocker's robot block by its row id, reporting whether a row
+// matched (so the caller can fall back to a human block).
+func (s *Store) deleteRobotBlock(ctx context.Context, blocker, id uuid.UUID) (bool, error) {
+	const q = `DELETE FROM backend.robot_blocks WHERE id = $2 AND blocker_id = $1`
+	res, err := s.db.ExecContext(ctx, q, blocker, id)
+	if err != nil {
+		return false, fmt.Errorf("social: delete robot block: %w", err)
+	}
+	n, err := res.RowsAffected()
+	if err != nil {
+		return false, fmt.Errorf("social: delete robot block rows: %w", err)
+	}
+	return n > 0, nil
+}
+
+// listRobotBlocks returns blocker's robot blocks, newest first.
+func (s *Store) listRobotBlocks(ctx context.Context, blocker uuid.UUID) ([]RobotBlock, error) {
+	const q = `SELECT id, display_name, game_id, seat FROM backend.robot_blocks
+WHERE blocker_id = $1 ORDER BY created_at DESC`
+	rows, err := s.db.QueryContext(ctx, q, blocker)
+	if err != nil {
+		return nil, fmt.Errorf("social: list robot blocks: %w", err)
+	}
+	defer rows.Close()
+	var out []RobotBlock
+	for rows.Next() {
+		var rb RobotBlock
+		var seat int16
+		if err := rows.Scan(&rb.ID, &rb.DisplayName, &rb.GameID, &seat); err != nil {
+			return nil, fmt.Errorf("social: scan robot block: %w", err)
+		}
+		rb.Seat = int(seat)
+		out = append(out, rb)
+	}
+	return out, rows.Err()
+}