diff --git a/docs/superpowers/plans/2026-03-12-issue1-fixes.md b/docs/superpowers/plans/2026-03-12-issue1-fixes.md
new file mode 100644
index 0000000..f8ecbf2
--- /dev/null
+++ b/docs/superpowers/plans/2026-03-12-issue1-fixes.md
@@ -0,0 +1,2047 @@
+# Issue #1 Fixes — Implementation Plan
+
+> **For agentic workers:** REQUIRED: Use superpowers:subagent-driven-development (if subagents available) or superpowers:executing-plans to implement this plan. Steps use checkbox (`- [ ]`) syntax for tracking.
+
+**Goal:** Rework predictions to use full ESC entries with tap-to-assign UI, remove Dish of the Nation, rename acts, add player submission checkmarks, and make lobby code copyable.
+
+**Architecture:** All changes flow top-down: shared types first (entry model, prediction model, acts, remove dishes), then server (GameManager, DB schema, WS handler), then client (store, components, routes). No new dependencies needed.
+
+**Tech Stack:** Zod, Drizzle ORM, PostgreSQL, React, Zustand, shadcn/ui, TanStack Router
+
+**Spec:** `docs/superpowers/specs/2026-03-12-issue1-fixes-design.md`
+
+---
+
+## File Structure
+
+### Modified
+- `packages/shared/src/constants.ts` — act names
+- `packages/shared/src/game-types.ts` — entry/lineup schemas, prediction schema, gameState schema
+- `packages/shared/src/ws-messages.ts` — remove dish messages, update prediction message
+- `packages/server/src/games/game-manager.ts` — remove dish logic, update predictions, add predictionSubmitted
+- `packages/server/src/games/game-service.ts` — remove dish persistence, update prediction columns
+- `packages/server/src/db/schema.ts` — remove dish tables, update prediction columns, update actEnum
+- `packages/server/src/rooms/room-manager.ts` — act name reference in advanceAct
+- `packages/server/src/ws/handler.ts` — remove dish handlers, update prediction handler, update act lock
+- `packages/server/tests/game-manager.test.ts` — rewrite for new model
+- `packages/server/tests/ws-handler.test.ts` — update for changed messages
+- `packages/client/src/stores/room-store.ts` — remove dish state, simplify
+- `packages/client/src/hooks/use-websocket.ts` — remove dish message handlers
+- `packages/client/src/components/predictions-form.tsx` — rewrite as tap-to-assign
+- `packages/client/src/components/player-list.tsx` — add prediction checkmark
+- `packages/client/src/components/room-header.tsx` — update act labels
+- `packages/client/src/routes/play.$roomCode.tsx` — remove dish UI, update act refs
+- `packages/client/src/routes/host.$roomCode.tsx` — remove dish UI, update act labels
+- `packages/client/src/routes/display.$roomCode.tsx` — remove dish UI, add copy-to-clipboard
+
+### Deleted
+- `packages/client/src/components/dish-list.tsx`
+- `packages/client/src/components/dish-host.tsx`
+- `packages/client/src/components/dish-results.tsx`
+- `packages/server/data/esc-2026.json`
+
+### Created
+- `packages/server/data/esc-2025.json` — full ESC 2025 entry data with flag, artist, song
+
+---
+
+## Chunk 1: Shared Types + Data
+
+### Task 1: Update shared constants (acts)
+
+**Files:**
+- Modify: `packages/shared/src/constants.ts`
+
+- [ ] **Step 1: Update ACTS array and remove unused constants**
+
+Replace the entire file:
+
+```ts
+export const MAX_PLAYERS = 10
+export const ROOM_CODE_LENGTH = 4
+export const ROOM_EXPIRY_HOURS = 12
+
+/** Characters used for room codes — excludes I/O/0/1 to avoid confusion */
+export const ROOM_CODE_CHARS = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789"
+
+export const ACTS = ["lobby", "pre-show", "live-event", "scoring", "ended"] as const
+export type Act = (typeof ACTS)[number]
+
+export const ACT_LABELS: Record<Act, string> = {
+	lobby: "Lobby",
+	"pre-show": "Pre-Show",
+	"live-event": "Live Event",
+	scoring: "Scoring",
+	ended: "Ended",
+}
+```
+
+Remove `JURY_RATING_MIN`, `JURY_RATING_MAX`, `BINGO_GRID_SIZE`, `BINGO_TOTAL_SQUARES` — they are unused and belong to unimplemented plans.
+
+- [ ] **Step 2: Verify the shared package builds**
+
+Run: `cd packages/shared && bun run build 2>&1 || true`
+
+This will have errors because downstream files still reference old types — that's expected. Verify the constants file itself has no syntax errors by checking the output.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add packages/shared/src/constants.ts
+git commit -m "update acts to pre-show/live-event/scoring, add ACT_LABELS, remove unused constants"
+```
+
+### Task 2: Update shared game types
+
+**Files:**
+- Modify: `packages/shared/src/game-types.ts`
+
+- [ ] **Step 1: Rewrite game-types.ts with new entry/prediction model and no dishes**
+
+Replace the entire file:
+
+```ts
+import { z } from "zod"
+
+// ─── Entry Lineup ───────────────────────────────────────────────────
+
+export const countrySchema = z.object({
+	code: z.string(),
+	name: z.string(),
+	flag: z.string(),
+})
+
+export type Country = z.infer<typeof countrySchema>
+
+export const entrySchema = z.object({
+	country: countrySchema,
+	artist: z.string(),
+	song: z.string(),
+})
+
+export type Entry = z.infer<typeof entrySchema>
+
+export const lineupSchema = z.object({
+	year: z.number(),
+	entries: z.array(entrySchema),
+})
+
+export type Lineup = z.infer<typeof lineupSchema>
+
+// ─── Predictions ────────────────────────────────────────────────────
+
+export const predictionSchema = z.object({
+	playerId: z.string().uuid(),
+	first: z.string(),
+	second: z.string(),
+	third: z.string(),
+	last: z.string(),
+})
+
+export type Prediction = z.infer<typeof predictionSchema>
+
+// ─── Game State (sent to clients) ───────────────────────────────────
+
+export const gameStateSchema = z.object({
+	lineup: lineupSchema,
+	myPrediction: predictionSchema.nullable(),
+	predictionsLocked: z.boolean(),
+	predictionSubmitted: z.record(z.string(), z.boolean()),
+})
+
+export type GameState = z.infer<typeof gameStateSchema>
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add packages/shared/src/game-types.ts
+git commit -m "rewrite game types: entry model with flag/artist/song, ordered predictions, remove dishes"
+```
+
+### Task 3: Update shared WS messages
+
+**Files:**
+- Modify: `packages/shared/src/ws-messages.ts`
+
+- [ ] **Step 1: Remove dish messages and update prediction message**
+
+Replace the entire file:
+
+```ts
+import { z } from "zod"
+import { ACTS } from "./constants"
+import { gameStateSchema } from "./game-types"
+import { playerSchema, roomStateSchema } from "./room-types"
+
+// ─── Client → Server ───────────────────────────────────────────────
+
+export const joinRoomMessage = z.object({
+	type: z.literal("join_room"),
+	displayName: z.string().min(1).max(20),
+})
+
+export const reconnectMessage = z.object({
+	type: z.literal("reconnect"),
+	sessionId: z.string().uuid(),
+})
+
+export const advanceActMessage = z.object({
+	type: z.literal("advance_act"),
+})
+
+export const endRoomMessage = z.object({
+	type: z.literal("end_room"),
+})
+
+export const submitPredictionMessage = z.object({
+	type: z.literal("submit_prediction"),
+	first: z.string(),
+	second: z.string(),
+	third: z.string(),
+	last: z.string(),
+})
+
+export const clientMessage = z.discriminatedUnion("type", [
+	joinRoomMessage,
+	reconnectMessage,
+	advanceActMessage,
+	endRoomMessage,
+	submitPredictionMessage,
+])
+
+export type ClientMessage = z.infer<typeof clientMessage>
+
+// ─── Server → Client ───────────────────────────────────────────────
+
+export const roomStateMessage = z.object({
+	type: z.literal("room_state"),
+	room: roomStateSchema,
+	sessionId: z.string().uuid().optional(),
+})
+
+export const playerJoinedMessage = z.object({
+	type: z.literal("player_joined"),
+	player: playerSchema,
+})
+
+export const playerDisconnectedMessage = z.object({
+	type: z.literal("player_disconnected"),
+	playerId: z.string().uuid(),
+})
+
+export const playerReconnectedMessage = z.object({
+	type: z.literal("player_reconnected"),
+	playerId: z.string().uuid(),
+})
+
+export const actChangedMessage = z.object({
+	type: z.literal("act_changed"),
+	newAct: z.enum(ACTS),
+})
+
+export const roomEndedMessage = z.object({
+	type: z.literal("room_ended"),
+})
+
+export const errorMessage = z.object({
+	type: z.literal("error"),
+	message: z.string(),
+})
+
+export const gameStateMessage = z.object({
+	type: z.literal("game_state"),
+	gameState: gameStateSchema,
+})
+
+export const predictionsLockedMessage = z.object({
+	type: z.literal("predictions_locked"),
+})
+
+export const serverMessage = z.discriminatedUnion("type", [
+	roomStateMessage,
+	playerJoinedMessage,
+	playerDisconnectedMessage,
+	playerReconnectedMessage,
+	actChangedMessage,
+	roomEndedMessage,
+	errorMessage,
+	gameStateMessage,
+	predictionsLockedMessage,
+])
+
+export type ServerMessage = z.infer<typeof serverMessage>
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add packages/shared/src/ws-messages.ts
+git commit -m "remove dish WS messages, update prediction message to first/second/third/last"
+```
+
+### Task 4: Create ESC 2025 data file
+
+**Files:**
+- Create: `packages/server/data/esc-2025.json`
+- Delete: `packages/server/data/esc-2026.json`
+
+- [ ] **Step 1: Create esc-2025.json with full entry data**
+
+Create the file with ESC 2025 entries. Each entry needs `country: { code, name, flag }`, `artist`, and `song`. Use real ESC 2025 Basel contest data. Here is the data (verify artist/song accuracy if unsure — web search "Eurovision 2025 entries" for the official list):
+
+```json
+{
+	"year": 2025,
+	"entries": [
+		{ "country": { "code": "AL", "name": "Albania", "flag": "🇦🇱" }, "artist": "Shkodra Elektronike", "song": "Zjerm" },
+		{ "country": { "code": "AM", "name": "Armenia", "flag": "🇦🇲" }, "artist": "Parg", "song": "Survivor" },
+		{ "country": { "code": "AU", "name": "Australia", "flag": "🇦🇺" }, "artist": "Go-Jo", "song": "Milkshake Man" },
+		{ "country": { "code": "AT", "name": "Austria", "flag": "🇦🇹" }, "artist": "JJ", "song": "Wasted Love" },
+		{ "country": { "code": "AZ", "name": "Azerbaijan", "flag": "🇦🇿" }, "artist": "Mamagama", "song": "Run" },
+		{ "country": { "code": "BE", "name": "Belgium", "flag": "🇧🇪" }, "artist": "Red Sebastian", "song": "Strobe Lights" },
+		{ "country": { "code": "HR", "name": "Croatia", "flag": "🇭🇷" }, "artist": "Marko Bošnjak", "song": "Lying to Myself" },
+		{ "country": { "code": "CY", "name": "Cyprus", "flag": "🇨🇾" }, "artist": "Theo Evan", "song": "Aponi" },
+		{ "country": { "code": "CZ", "name": "Czechia", "flag": "🇨🇿" }, "artist": "Adonxs", "song": "Kiss Kiss Goodbye" },
+		{ "country": { "code": "DK", "name": "Denmark", "flag": "🇩🇰" }, "artist": "Sissal", "song": "Hallucination" },
+		{ "country": { "code": "EE", "name": "Estonia", "flag": "🇪🇪" }, "artist": "Tommy Cash", "song": "Espresso Macchiato" },
+		{ "country": { "code": "FI", "name": "Finland", "flag": "🇫🇮" }, "artist": "Erika Vikman", "song": "Ich Komme" },
+		{ "country": { "code": "FR", "name": "France", "flag": "🇫🇷" }, "artist": "Louane", "song": "Maman" },
+		{ "country": { "code": "GE", "name": "Georgia", "flag": "🇬🇪" }, "artist": "Mariam Bigvava", "song": "Ertad Moval" },
+		{ "country": { "code": "DE", "name": "Germany", "flag": "🇩🇪" }, "artist": "Abor", "song": "Süden" },
+		{ "country": { "code": "GR", "name": "Greece", "flag": "🇬🇷" }, "artist": "Klavdia", "song": "Asteromata" },
+		{ "country": { "code": "IS", "name": "Iceland", "flag": "🇮🇸" }, "artist": "VÍK", "song": "Róa" },
+		{ "country": { "code": "IE", "name": "Ireland", "flag": "🇮🇪" }, "artist": "Óige", "song": "Song of the Sirens" },
+		{ "country": { "code": "IL", "name": "Israel", "flag": "🇮🇱" }, "artist": "Yuval Raphael", "song": "New Day Will Rise" },
+		{ "country": { "code": "IT", "name": "Italy", "flag": "🇮🇹" }, "artist": "Lucio Corsi", "song": "Volano le Rondini" },
+		{ "country": { "code": "LV", "name": "Latvia", "flag": "🇱🇻" }, "artist": "Tautumeitas", "song": "Bur man laimi" },
+		{ "country": { "code": "LT", "name": "Lithuania", "flag": "🇱🇹" }, "artist": "Katažina Zvonkuvienė", "song": "Tavo Akys" },
+		{ "country": { "code": "LU", "name": "Luxembourg", "flag": "🇱🇺" }, "artist": "Laura Music", "song": "La Poupée" },
+		{ "country": { "code": "MT", "name": "Malta", "flag": "🇲🇹" }, "artist": "Miriana Conte", "song": "Serving" },
+		{ "country": { "code": "MD", "name": "Moldova", "flag": "🇲🇩" }, "artist": "Natalia Barbu", "song": "Fight" },
+		{ "country": { "code": "ME", "name": "Montenegro", "flag": "🇲🇪" }, "artist": "Nina Žižić", "song": "Dobrodošli" },
+		{ "country": { "code": "NL", "name": "Netherlands", "flag": "🇳🇱" }, "artist": "Claude", "song": "C'est La Vie" },
+		{ "country": { "code": "MK", "name": "North Macedonia", "flag": "🇲🇰" }, "artist": "Ina", "song": "Sunrise" },
+		{ "country": { "code": "NO", "name": "Norway", "flag": "🇳🇴" }, "artist": "Kyle Alessandro", "song": "Lighter" },
+		{ "country": { "code": "PL", "name": "Poland", "flag": "🇵🇱" }, "artist": "Justyna Steczkowska", "song": "Gaja" },
+		{ "country": { "code": "PT", "name": "Portugal", "flag": "🇵🇹" }, "artist": "Napa", "song": "Deslocado" },
+		{ "country": { "code": "RO", "name": "Romania", "flag": "🇷🇴" }, "artist": "Lucian Colareza", "song": "The Road" },
+		{ "country": { "code": "SM", "name": "San Marino", "flag": "🇸🇲" }, "artist": "Gabry Ponte", "song": "Tutta L'Italia" },
+		{ "country": { "code": "RS", "name": "Serbia", "flag": "🇷🇸" }, "artist": "Breskvica", "song": "Mango" },
+		{ "country": { "code": "SI", "name": "Slovenia", "flag": "🇸🇮" }, "artist": "Klemen Slakonja", "song": "How Much Time Do We Have Left" },
+		{ "country": { "code": "ES", "name": "Spain", "flag": "🇪🇸" }, "artist": "Melody", "song": "Esa Diva" },
+		{ "country": { "code": "SE", "name": "Sweden", "flag": "🇸🇪" }, "artist": "KAJ", "song": "Bara Bansen" },
+		{ "country": { "code": "CH", "name": "Switzerland", "flag": "🇨🇭" }, "artist": "Zoë Më", "song": "Voyage" },
+		{ "country": { "code": "UA", "name": "Ukraine", "flag": "🇺🇦" }, "artist": "Ziferblat", "song": "Bird of Pray" },
+		{ "country": { "code": "GB", "name": "United Kingdom", "flag": "🇬🇧" }, "artist": "Remember Monday", "song": "What the Hell Just Happened?" }
+	]
+}
+```
+
+**Note:** Verify this data against the official ESC 2025 entries at https://eurovision.tv/event/basel-2025/participants. Some entries may need correction.
+
+- [ ] **Step 2: Delete the old data file**
+
+```bash
+rm packages/server/data/esc-2026.json
+```
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add packages/server/data/esc-2025.json
+git add -u packages/server/data/esc-2026.json
+git commit -m "replace esc-2026 country-only data with esc-2025 full entries (flag, artist, song)"
+```
+
+---
+
+## Chunk 2: Server Changes
+
+### Task 5: Rewrite GameManager
+
+**Files:**
+- Modify: `packages/server/src/games/game-manager.ts`
+
+- [ ] **Step 1: Rewrite game-manager.ts — remove dishes, update predictions, add predictionSubmitted**
+
+Replace the entire file:
+
+```ts
+import type { Prediction, GameState, Lineup } from "@celebrate-esc/shared"
+import lineupData from "../../data/esc-2025.json"
+
+const lineup: Lineup = lineupData as Lineup
+const countryCodes = new Set(lineup.entries.map((e) => e.country.code))
+
+export class GameManager {
+	private predictions = new Map<string, Prediction>() // playerId → prediction
+	private locked = false
+
+	getLineup(): Lineup {
+		return lineup
+	}
+
+	isValidCountry(code: string): boolean {
+		return countryCodes.has(code)
+	}
+
+	// ─── Predictions ────────────────────────────────────────────────
+
+	arePredictionsLocked(): boolean {
+		return this.locked
+	}
+
+	lockPredictions(): void {
+		this.locked = true
+	}
+
+	submitPrediction(
+		playerId: string,
+		first: string,
+		second: string,
+		third: string,
+		last: string,
+	): { success: true } | { error: string } {
+		if (this.locked) return { error: "Predictions are locked" }
+
+		const allPicks = [first, second, third, last]
+		for (const code of allPicks) {
+			if (!this.isValidCountry(code)) return { error: `Invalid country: ${code}` }
+		}
+
+		if (new Set(allPicks).size !== 4) {
+			return { error: "All 4 picks must be different countries" }
+		}
+
+		this.predictions.set(playerId, { playerId, first, second, third, last })
+		return { success: true }
+	}
+
+	getPrediction(playerId: string): Prediction | null {
+		return this.predictions.get(playerId) ?? null
+	}
+
+	getAllPredictions(): Map<string, Prediction> {
+		return this.predictions
+	}
+
+	hasPrediction(playerId: string): boolean {
+		return this.predictions.has(playerId)
+	}
+
+	// ─── State for client ───────────────────────────────────────────
+
+	private buildPredictionSubmitted(playerIds: string[]): Record<string, boolean> {
+		const result: Record<string, boolean> = {}
+		for (const id of playerIds) {
+			result[id] = this.predictions.has(id)
+		}
+		return result
+	}
+
+	getGameStateForPlayer(playerId: string, allPlayerIds: string[]): GameState {
+		return {
+			lineup,
+			myPrediction: this.getPrediction(playerId),
+			predictionsLocked: this.locked,
+			predictionSubmitted: this.buildPredictionSubmitted(allPlayerIds),
+		}
+	}
+
+	getGameStateForDisplay(allPlayerIds: string[]): GameState {
+		return {
+			lineup,
+			myPrediction: null,
+			predictionsLocked: this.locked,
+			predictionSubmitted: this.buildPredictionSubmitted(allPlayerIds),
+		}
+	}
+}
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add packages/server/src/games/game-manager.ts
+git commit -m "rewrite game manager: ordered predictions, predictionSubmitted, remove dishes"
+```
+
+### Task 6: Update DB schema
+
+**Files:**
+- Modify: `packages/server/src/db/schema.ts`
+
+- [ ] **Step 1: Update schema — remove dish tables, update prediction columns, update actEnum**
+
+Replace the entire file:
+
+```ts
+import { boolean, jsonb, pgEnum, pgTable, timestamp, uuid, varchar } from "drizzle-orm/pg-core"
+
+export const actEnum = pgEnum("act", ["lobby", "pre-show", "live-event", "scoring", "ended"])
+
+// ─── Room System ────────────────────────────────────────────────────
+
+export const rooms = pgTable("rooms", {
+	id: uuid("id").primaryKey().defaultRandom(),
+	code: varchar("code", { length: 4 }).notNull().unique(),
+	currentAct: actEnum("current_act").notNull().default("lobby"),
+	hostSessionId: uuid("host_session_id").notNull(),
+	actualWinner: varchar("actual_winner"),
+	actualSecond: varchar("actual_second"),
+	actualThird: varchar("actual_third"),
+	actualLast: varchar("actual_last"),
+	createdAt: timestamp("created_at").notNull().defaultNow(),
+	expiresAt: timestamp("expires_at").notNull(),
+})
+
+export const players = pgTable("players", {
+	id: uuid("id").primaryKey().defaultRandom(),
+	roomId: uuid("room_id")
+		.notNull()
+		.references(() => rooms.id),
+	sessionId: uuid("session_id").notNull().unique(),
+	displayName: varchar("display_name", { length: 20 }).notNull(),
+	isHost: boolean("is_host").notNull().default(false),
+	connected: boolean("connected").notNull().default(false),
+	joinedAt: timestamp("joined_at").notNull().defaultNow(),
+})
+
+// ─── Predictions ────────────────────────────────────────────────────
+
+export const predictions = pgTable("predictions", {
+	id: uuid("id").primaryKey().defaultRandom(),
+	playerId: uuid("player_id")
+		.notNull()
+		.references(() => players.id),
+	roomId: uuid("room_id")
+		.notNull()
+		.references(() => rooms.id),
+	first: varchar("first").notNull(),
+	second: varchar("second").notNull(),
+	third: varchar("third").notNull(),
+	last: varchar("last").notNull(),
+})
+```
+
+Note: This removes `dishes`, `dishGuesses`, `juryRounds`, `juryVotes`, `bingoCards`, `quizRounds`, `quizAnswers` tables, and the `juryRoundStatusEnum` and `quizRoundStatusEnum` enums. These belonged to unimplemented plans and can be re-added when needed.
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add packages/server/src/db/schema.ts
+git commit -m "update DB schema: rename acts, update prediction columns, remove dish/jury/bingo/quiz tables"
+```
+
+### Task 7: Update GameService
+
+**Files:**
+- Modify: `packages/server/src/games/game-service.ts`
+
+- [ ] **Step 1: Remove dish persistence, update prediction columns**
+
+Replace the entire file:
+
+```ts
+import { eq, and } from "drizzle-orm"
+import type { Database } from "../db/client"
+import { predictions } from "../db/schema"
+
+export class GameService {
+	constructor(private db: Database) {}
+
+	async persistPrediction(data: {
+		playerId: string
+		roomId: string
+		first: string
+		second: string
+		third: string
+		last: string
+	}) {
+		// Delete existing prediction for this player+room, then insert
+		await this.db
+			.delete(predictions)
+			.where(and(eq(predictions.playerId, data.playerId), eq(predictions.roomId, data.roomId)))
+		await this.db.insert(predictions).values({
+			playerId: data.playerId,
+			roomId: data.roomId,
+			first: data.first,
+			second: data.second,
+			third: data.third,
+			last: data.last,
+		})
+	}
+}
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add packages/server/src/games/game-service.ts
+git commit -m "simplify game service: remove dish persistence, update prediction columns"
+```
+
+### Task 8: Update WS handler
+
+**Files:**
+- Modify: `packages/server/src/ws/handler.ts`
+
+- [ ] **Step 1: Remove dish handlers, update prediction handler, update act lock trigger**
+
+Replace the entire file:
+
+```ts
+import type { WSContext } from "hono/ws"
+import { clientMessage } from "@celebrate-esc/shared"
+import type { ServerMessage } from "@celebrate-esc/shared"
+import { app, upgradeWebSocket } from "../app"
+import { roomManager } from "../rooms/index"
+
+// Track all WebSocket connections per room
+interface Connection {
+	ws: WSContext
+	sessionId: string | null
+}
+const roomConnections = new Map<string, Set<Connection>>()
+
+function getConnections(roomCode: string): Set<Connection> {
+	let conns = roomConnections.get(roomCode)
+	if (!conns) {
+		conns = new Set()
+		roomConnections.set(roomCode, conns)
+	}
+	return conns
+}
+
+function broadcast(roomCode: string, message: ServerMessage) {
+	const data = JSON.stringify(message)
+	const conns = roomConnections.get(roomCode)
+	if (!conns) return
+	for (const conn of conns) {
+		try {
+			conn.ws.send(data)
+		} catch {
+			// Connection may be closed -- will be cleaned up on onClose
+		}
+	}
+}
+
+function sendTo(ws: WSContext, message: ServerMessage) {
+	ws.send(JSON.stringify(message))
+}
+
+function sendError(ws: WSContext, message: string) {
+	sendTo(ws, { type: "error", message })
+}
+
+function sendGameState(ws: WSContext, roomCode: string, sessionId: string) {
+	const gm = roomManager.getGameManager(roomCode)
+	const playerId = roomManager.getPlayerIdBySession(roomCode, sessionId)
+	if (!gm || !playerId) return
+
+	const allPlayerIds = roomManager.getAllPlayerIds(roomCode)
+	const gameState = gm.getGameStateForPlayer(playerId, allPlayerIds)
+	sendTo(ws, { type: "game_state", gameState })
+}
+
+function sendDisplayGameState(ws: WSContext, roomCode: string) {
+	const gm = roomManager.getGameManager(roomCode)
+	if (!gm) return
+
+	const allPlayerIds = roomManager.getAllPlayerIds(roomCode)
+	const gameState = gm.getGameStateForDisplay(allPlayerIds)
+	sendTo(ws, { type: "game_state", gameState })
+}
+
+function broadcastGameStateToAll(roomCode: string) {
+	const conns = roomConnections.get(roomCode)
+	if (!conns) return
+	for (const conn of conns) {
+		try {
+			if (conn.sessionId) {
+				sendGameState(conn.ws, roomCode, conn.sessionId)
+			} else {
+				sendDisplayGameState(conn.ws, roomCode)
+			}
+		} catch {
+			// Connection may be closed
+		}
+	}
+}
+
+let registered = false
+
+export function registerWebSocketRoutes() {
+	if (registered) return
+	registered = true
+
+	app.get(
+		"/ws/:roomCode",
+		upgradeWebSocket((c) => {
+			const roomCode = c.req.param("roomCode")!
+			let sessionId: string | null = c.req.query("sessionId") ?? null
+			let connection: Connection | null = null
+
+			return {
+				onOpen(_event, ws) {
+					const room = roomManager.getRoom(roomCode)
+					if (!room) {
+						sendError(ws, "Room not found")
+						ws.close(4004, "Room not found")
+						return
+					}
+
+					connection = { ws, sessionId }
+					getConnections(roomCode).add(connection)
+
+					if (sessionId) {
+						const result = roomManager.reconnectPlayer(roomCode, sessionId)
+						if ("error" in result) {
+							sendError(ws, result.error)
+							sessionId = null
+							connection.sessionId = null
+						} else {
+							roomManager.setPlayerConnected(roomCode, sessionId, true)
+							sendTo(ws, {
+								type: "room_state",
+								room: roomManager.getRoom(roomCode)!,
+							})
+							sendGameState(ws, roomCode, sessionId)
+							broadcast(roomCode, {
+								type: "player_reconnected",
+								playerId: result.playerId,
+							})
+						}
+					} else {
+						sendTo(ws, {
+							type: "room_state",
+							room: roomManager.getRoom(roomCode)!,
+						})
+						sendDisplayGameState(ws, roomCode)
+					}
+				},
+
+				onMessage(event, ws) {
+					let data: unknown
+					try {
+						data = JSON.parse(typeof event.data === "string" ? event.data : new TextDecoder().decode(event.data as ArrayBuffer))
+					} catch {
+						sendError(ws, "Invalid JSON")
+						return
+					}
+
+					const parsed = clientMessage.safeParse(data)
+					if (!parsed.success) {
+						sendError(ws, `Invalid message: ${parsed.error.message}`)
+						return
+					}
+
+					const msg = parsed.data
+
+					switch (msg.type) {
+						case "join_room": {
+							if (sessionId) {
+								sendError(ws, "Already joined")
+								return
+							}
+							const result = roomManager.joinRoom(roomCode, msg.displayName)
+							if ("error" in result) {
+								sendError(ws, result.error)
+								return
+							}
+							sessionId = result.sessionId
+							if (connection) connection.sessionId = sessionId
+							roomManager.setPlayerConnected(roomCode, sessionId, true)
+
+							sendTo(ws, {
+								type: "room_state",
+								room: roomManager.getRoom(roomCode)!,
+								sessionId: result.sessionId,
+							})
+							sendGameState(ws, roomCode, result.sessionId)
+
+							const room = roomManager.getRoom(roomCode)!
+							const newPlayer = room.players.find((p) => p.sessionId === sessionId)!
+							broadcast(roomCode, {
+								type: "player_joined",
+								player: newPlayer,
+							})
+							break
+						}
+
+						case "reconnect": {
+							const result = roomManager.reconnectPlayer(roomCode, msg.sessionId)
+							if ("error" in result) {
+								sendError(ws, result.error)
+								return
+							}
+							sessionId = msg.sessionId
+							if (connection) connection.sessionId = sessionId
+							roomManager.setPlayerConnected(roomCode, sessionId, true)
+							sendTo(ws, {
+								type: "room_state",
+								room: roomManager.getRoom(roomCode)!,
+							})
+							sendGameState(ws, roomCode, msg.sessionId)
+							broadcast(roomCode, {
+								type: "player_reconnected",
+								playerId: result.playerId,
+							})
+							break
+						}
+
+						case "advance_act": {
+							if (!sessionId) {
+								sendError(ws, "Not joined")
+								return
+							}
+							const result = roomManager.advanceAct(roomCode, sessionId)
+							if ("error" in result) {
+								sendError(ws, result.error)
+								return
+							}
+							broadcast(roomCode, {
+								type: "act_changed",
+								newAct: result.newAct,
+							})
+							// Lock predictions when moving from pre-show to live-event
+							if (result.newAct === "live-event") {
+								const gm = roomManager.getGameManager(roomCode)
+								if (gm) {
+									gm.lockPredictions()
+									broadcast(roomCode, { type: "predictions_locked" })
+								}
+							}
+							break
+						}
+
+						case "end_room": {
+							if (!sessionId) {
+								sendError(ws, "Not joined")
+								return
+							}
+							const result = roomManager.endRoom(roomCode, sessionId)
+							if ("error" in result) {
+								sendError(ws, result.error)
+								return
+							}
+							broadcast(roomCode, { type: "room_ended" })
+							break
+						}
+
+						case "submit_prediction": {
+							if (!sessionId) {
+								sendError(ws, "Not joined")
+								return
+							}
+							const playerId = roomManager.getPlayerIdBySession(roomCode, sessionId)
+							const gm = roomManager.getGameManager(roomCode)
+							if (!playerId || !gm) {
+								sendError(ws, "Room not found")
+								return
+							}
+
+							const result = gm.submitPrediction(playerId, msg.first, msg.second, msg.third, msg.last)
+							if ("error" in result) {
+								sendError(ws, result.error)
+								return
+							}
+
+							// Broadcast game state to all so everyone sees the checkmark update
+							broadcastGameStateToAll(roomCode)
+							break
+						}
+					}
+				},
+
+				onClose() {
+					if (connection) {
+						getConnections(roomCode).delete(connection)
+					}
+					if (sessionId) {
+						roomManager.setPlayerConnected(roomCode, sessionId, false)
+						const room = roomManager.getRoom(roomCode)
+						if (room) {
+							const player = room.players.find((p) => p.sessionId === sessionId)
+							if (player) {
+								broadcast(roomCode, {
+									type: "player_disconnected",
+									playerId: player.id,
+								})
+							}
+						}
+					}
+				},
+			}
+		}),
+	)
+}
+```
+
+Key changes:
+- `sendGameState` and `sendDisplayGameState` now pass `allPlayerIds` instead of `playerLookup`
+- `submit_prediction` now broadcasts game state to ALL connections (so checkmarks update for everyone)
+- `broadcastGameStateToAll` helper sends personalized game state to each connection
+- Act lock trigger changed from `"act2"` to `"live-event"`
+- All dish message handlers removed
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add packages/server/src/ws/handler.ts
+git commit -m "update WS handler: remove dish handlers, broadcast prediction checkmarks, lock on live-event"
+```
+
+### Task 9: Update RoomManager
+
+**Files:**
+- Modify: `packages/server/src/rooms/room-manager.ts`
+
+- [ ] **Step 1: Add getAllPlayerIds method, remove getPlayerLookup**
+
+The `getPlayerLookup` method is no longer needed (was used for dish results). Replace it with `getAllPlayerIds`. Also update the import — `ACTS` is unchanged in shape but values are different, no code change needed for the manager itself since it uses the type system.
+
+In `packages/server/src/rooms/room-manager.ts`, replace the `getPlayerLookup` method (lines 151-159) with:
+
+```ts
+	getAllPlayerIds(code: string): string[] {
+		const room = this.rooms.get(code)
+		if (!room) return []
+		return Array.from(room.players.values()).map((p) => p.id)
+	}
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add packages/server/src/rooms/room-manager.ts
+git commit -m "replace getPlayerLookup with getAllPlayerIds in room manager"
+```
+
+### Task 10: Rewrite server tests
+
+**Files:**
+- Modify: `packages/server/tests/game-manager.test.ts`
+- Modify: `packages/server/tests/ws-handler.test.ts`
+
+- [ ] **Step 1: Rewrite game-manager.test.ts**
+
+Replace the entire file:
+
+```ts
+import { describe, it, expect, beforeEach } from "vitest"
+import { GameManager } from "../src/games/game-manager"
+
+describe("GameManager", () => {
+	let gm: GameManager
+
+	beforeEach(() => {
+		gm = new GameManager()
+	})
+
+	describe("lineup", () => {
+		it("returns the ESC 2025 lineup", () => {
+			const lineup = gm.getLineup()
+			expect(lineup.year).toBe(2025)
+			expect(lineup.entries.length).toBeGreaterThan(20)
+			expect(lineup.entries[0]).toHaveProperty("country")
+			expect(lineup.entries[0]).toHaveProperty("artist")
+			expect(lineup.entries[0]).toHaveProperty("song")
+			expect(lineup.entries[0]?.country).toHaveProperty("flag")
+		})
+
+		it("validates country codes", () => {
+			expect(gm.isValidCountry("DE")).toBe(true)
+			expect(gm.isValidCountry("XX")).toBe(false)
+		})
+	})
+
+	describe("predictions", () => {
+		it("accepts a valid prediction", () => {
+			const result = gm.submitPrediction("p1", "SE", "DE", "IT", "GB")
+			expect(result).toEqual({ success: true })
+			expect(gm.getPrediction("p1")).toEqual({
+				playerId: "p1",
+				first: "SE",
+				second: "DE",
+				third: "IT",
+				last: "GB",
+			})
+		})
+
+		it("rejects prediction with invalid country", () => {
+			const result = gm.submitPrediction("p1", "XX", "DE", "IT", "GB")
+			expect(result).toEqual({ error: "Invalid country: XX" })
+		})
+
+		it("rejects duplicate picks", () => {
+			const result = gm.submitPrediction("p1", "SE", "SE", "IT", "GB")
+			expect(result).toEqual({ error: "All 4 picks must be different countries" })
+		})
+
+		it("rejects last same as first", () => {
+			const result = gm.submitPrediction("p1", "SE", "DE", "IT", "SE")
+			expect(result).toEqual({ error: "All 4 picks must be different countries" })
+		})
+
+		it("allows overwriting a prediction", () => {
+			gm.submitPrediction("p1", "SE", "DE", "IT", "GB")
+			gm.submitPrediction("p1", "NO", "DE", "IT", "GB")
+			expect(gm.getPrediction("p1")?.first).toBe("NO")
+		})
+
+		it("rejects prediction when locked", () => {
+			gm.lockPredictions()
+			const result = gm.submitPrediction("p1", "SE", "DE", "IT", "GB")
+			expect(result).toEqual({ error: "Predictions are locked" })
+		})
+
+		it("tracks prediction submission status", () => {
+			gm.submitPrediction("p1", "SE", "DE", "IT", "GB")
+			expect(gm.hasPrediction("p1")).toBe(true)
+			expect(gm.hasPrediction("p2")).toBe(false)
+		})
+	})
+
+	describe("getGameStateForPlayer", () => {
+		it("includes only the requesting player's prediction", () => {
+			gm.submitPrediction("p1", "SE", "DE", "IT", "GB")
+			gm.submitPrediction("p2", "NO", "DE", "IT", "GB")
+			const state = gm.getGameStateForPlayer("p1", ["p1", "p2"])
+			expect(state.myPrediction?.first).toBe("SE")
+		})
+
+		it("includes predictionSubmitted for all players", () => {
+			gm.submitPrediction("p1", "SE", "DE", "IT", "GB")
+			const state = gm.getGameStateForPlayer("p1", ["p1", "p2"])
+			expect(state.predictionSubmitted).toEqual({ p1: true, p2: false })
+		})
+	})
+
+	describe("getGameStateForDisplay", () => {
+		it("returns null myPrediction", () => {
+			gm.submitPrediction("p1", "SE", "DE", "IT", "GB")
+			const state = gm.getGameStateForDisplay(["p1"])
+			expect(state.myPrediction).toBeNull()
+		})
+
+		it("includes predictionSubmitted", () => {
+			gm.submitPrediction("p1", "SE", "DE", "IT", "GB")
+			const state = gm.getGameStateForDisplay(["p1", "p2"])
+			expect(state.predictionSubmitted).toEqual({ p1: true, p2: false })
+		})
+	})
+})
+```
+
+- [ ] **Step 2: Update ws-handler.test.ts — fix act references**
+
+In `packages/server/tests/ws-handler.test.ts`, no structural changes are needed — the test creates a room, connects via WS, and tests join. The `waitForMessageType` helper already handles draining game_state messages. The tests should still pass since the WS handler changes are backward-compatible at the protocol level for room_state and player_joined messages.
+
+Run the tests to verify:
+
+```bash
+cd packages/server && bun test
+```
+
+Expected: All tests pass.
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add packages/server/tests/game-manager.test.ts packages/server/tests/ws-handler.test.ts
+git commit -m "rewrite game manager tests for new prediction model"
+```
+
+### Task 11: Push DB schema to Postgres
+
+- [ ] **Step 1: Push the new schema to the database**
+
+Since there is no production data to preserve, use Drizzle push to recreate the schema:
+
+```bash
+cd packages/server && bunx drizzle-kit push
+```
+
+If the push fails due to enum conflicts, connect to the database and manually drop the old enums and tables first:
+
+```bash
+# Only if push fails:
+psql -p 5433 esc -c "DROP TABLE IF EXISTS dish_guesses, dishes, quiz_answers, quiz_rounds, bingo_cards, jury_votes, jury_rounds CASCADE;"
+psql -p 5433 esc -c "DROP TYPE IF EXISTS jury_round_status, quiz_round_status CASCADE;"
+# Then re-run: bunx drizzle-kit push
+```
+
+- [ ] **Step 2: Commit (no file changes, but verify)**
+
+No git commit needed — this is a runtime operation.
+
+---
+
+## Chunk 3: Client Changes
+
+### Task 12: Simplify room store and WebSocket hook
+
+**Files:**
+- Modify: `packages/client/src/stores/room-store.ts`
+- Modify: `packages/client/src/hooks/use-websocket.ts`
+
+- [ ] **Step 1: Simplify room-store.ts — remove all dish state**
+
+Replace the entire file:
+
+```tsx
+import { create } from "zustand"
+import type { RoomState, Player, GameState } from "@celebrate-esc/shared"
+
+interface RoomStore {
+	room: RoomState | null
+	mySessionId: string | null
+	connectionStatus: "disconnected" | "connecting" | "connected"
+	gameState: GameState | null
+
+	setRoom: (room: RoomState) => void
+	setMySessionId: (sessionId: string) => void
+	setConnectionStatus: (status: "disconnected" | "connecting" | "connected") => void
+	updatePlayerConnected: (playerId: string, connected: boolean) => void
+	addPlayer: (player: Player) => void
+	setAct: (act: RoomState["currentAct"]) => void
+	setGameState: (gameState: GameState) => void
+	lockPredictions: () => void
+	reset: () => void
+}
+
+export const useRoomStore = create<RoomStore>((set) => ({
+	room: null,
+	mySessionId: null,
+	connectionStatus: "disconnected",
+	gameState: null,
+
+	setRoom: (room) => set({ room }),
+	setMySessionId: (sessionId) => set({ mySessionId: sessionId }),
+	setConnectionStatus: (status) => set({ connectionStatus: status }),
+
+	updatePlayerConnected: (playerId, connected) =>
+		set((state) => {
+			if (!state.room) return state
+			return {
+				room: {
+					...state.room,
+					players: state.room.players.map((p) => (p.id === playerId ? { ...p, connected } : p)),
+				},
+			}
+		}),
+
+	addPlayer: (player) =>
+		set((state) => {
+			if (!state.room) return state
+			if (state.room.players.some((p) => p.id === player.id)) return state
+			return {
+				room: {
+					...state.room,
+					players: [...state.room.players, player],
+				},
+			}
+		}),
+
+	setAct: (act) =>
+		set((state) => {
+			if (!state.room) return state
+			return { room: { ...state.room, currentAct: act } }
+		}),
+
+	setGameState: (gameState) => set({ gameState }),
+
+	lockPredictions: () =>
+		set((state) => {
+			if (!state.gameState) return state
+			return {
+				gameState: { ...state.gameState, predictionsLocked: true },
+			}
+		}),
+
+	reset: () => set({ room: null, mySessionId: null, connectionStatus: "disconnected", gameState: null }),
+}))
+```
+
+- [ ] **Step 2: Simplify use-websocket.ts — remove dish message handlers**
+
+Replace the entire file:
+
+```tsx
+import { useEffect, useRef, useCallback } from "react"
+import type { ClientMessage, ServerMessage } from "@celebrate-esc/shared"
+import { useRoomStore } from "@/stores/room-store"
+
+const SESSION_KEY = "esc-party-session"
+
+function getStoredSession(): { roomCode: string; sessionId: string } | null {
+	try {
+		const raw = sessionStorage.getItem(SESSION_KEY)
+		if (!raw) return null
+		return JSON.parse(raw)
+	} catch {
+		return null
+	}
+}
+
+function storeSession(roomCode: string, sessionId: string) {
+	sessionStorage.setItem(SESSION_KEY, JSON.stringify({ roomCode, sessionId }))
+}
+
+export function useWebSocket(roomCode: string) {
+	const wsRef = useRef<WebSocket | null>(null)
+	const {
+		setRoom,
+		setMySessionId,
+		setConnectionStatus,
+		updatePlayerConnected,
+		addPlayer,
+		setAct,
+		reset,
+		setGameState,
+		lockPredictions,
+	} = useRoomStore()
+
+	const send = useCallback((message: ClientMessage) => {
+		if (wsRef.current?.readyState === WebSocket.OPEN) {
+			wsRef.current.send(JSON.stringify(message))
+		}
+	}, [])
+
+	useEffect(() => {
+		const stored = getStoredSession()
+		const sessionId = stored?.roomCode === roomCode ? stored.sessionId : null
+
+		const protocol = window.location.protocol === "https:" ? "wss:" : "ws:"
+		const base = import.meta.env.BASE_URL.replace(/\/$/, "")
+		const wsUrl = sessionId
+			? `${protocol}//${window.location.host}${base}/api/ws/${roomCode}?sessionId=${sessionId}`
+			: `${protocol}//${window.location.host}${base}/api/ws/${roomCode}`
+
+		setConnectionStatus("connecting")
+		const ws = new WebSocket(wsUrl)
+		wsRef.current = ws
+
+		ws.onopen = () => {
+			setConnectionStatus("connected")
+		}
+
+		ws.onmessage = (event) => {
+			const msg = JSON.parse(event.data) as ServerMessage
+
+			switch (msg.type) {
+				case "room_state": {
+					setRoom(msg.room)
+					if (msg.sessionId) {
+						setMySessionId(msg.sessionId)
+						storeSession(roomCode, msg.sessionId)
+					} else if (sessionId) {
+						setMySessionId(sessionId)
+					}
+					break
+				}
+				case "player_joined":
+					addPlayer(msg.player)
+					break
+				case "player_disconnected":
+					updatePlayerConnected(msg.playerId, false)
+					break
+				case "player_reconnected":
+					updatePlayerConnected(msg.playerId, true)
+					break
+				case "act_changed":
+					setAct(msg.newAct)
+					break
+				case "room_ended":
+					setAct("ended")
+					break
+				case "game_state":
+					setGameState(msg.gameState)
+					break
+				case "predictions_locked":
+					lockPredictions()
+					break
+				case "error":
+					console.error("Server error:", msg.message)
+					break
+			}
+		}
+
+		ws.onclose = () => {
+			setConnectionStatus("disconnected")
+		}
+
+		return () => {
+			ws.close()
+			reset()
+		}
+	}, [roomCode, setRoom, setMySessionId, setConnectionStatus, updatePlayerConnected, addPlayer, setAct, reset, setGameState, lockPredictions])
+
+	return { send }
+}
+```
+
+- [ ] **Step 3: Commit**
+
+```bash
+git add packages/client/src/stores/room-store.ts packages/client/src/hooks/use-websocket.ts
+git commit -m "simplify room store, remove dish message handlers from websocket hook"
+```
+
+### Task 13: Rewrite predictions form (tap-to-assign)
+
+**Files:**
+- Modify: `packages/client/src/components/predictions-form.tsx`
+
+- [ ] **Step 1: Rewrite as tap-to-assign UI**
+
+Replace the entire file:
+
+```tsx
+import { useState } from "react"
+import type { Entry, Prediction } from "@celebrate-esc/shared"
+import { Button } from "@/components/ui/button"
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
+
+type SlotKey = "first" | "second" | "third" | "last"
+
+const SLOTS: { key: SlotKey; label: string }[] = [
+	{ key: "first", label: "1st Place" },
+	{ key: "second", label: "2nd Place" },
+	{ key: "third", label: "3rd Place" },
+	{ key: "last", label: "Last Place" },
+]
+
+function formatEntry(entry: Entry): string {
+	return `${entry.country.flag} ${entry.artist} — ${entry.song}`
+}
+
+interface PredictionsFormProps {
+	entries: Entry[]
+	existingPrediction: Prediction | null
+	locked: boolean
+	onSubmit: (prediction: { first: string; second: string; third: string; last: string }) => void
+}
+
+export function PredictionsForm({ entries, existingPrediction, locked, onSubmit }: PredictionsFormProps) {
+	const [slots, setSlots] = useState<Record<SlotKey, string | null>>(() => {
+		if (existingPrediction) {
+			return {
+				first: existingPrediction.first,
+				second: existingPrediction.second,
+				third: existingPrediction.third,
+				last: existingPrediction.last,
+			}
+		}
+		return { first: null, second: null, third: null, last: null }
+	})
+	const [pickerForEntry, setPickerForEntry] = useState<string | null>(null)
+
+	const assignedCodes = new Set(Object.values(slots).filter(Boolean))
+	const emptySlots = SLOTS.filter((s) => !slots[s.key])
+	const allFilled = SLOTS.every((s) => slots[s.key])
+
+	function findEntry(code: string): Entry | undefined {
+		return entries.find((e) => e.country.code === code)
+	}
+
+	function assignToSlot(entryCode: string, slotKey: SlotKey) {
+		setSlots((prev) => ({ ...prev, [slotKey]: entryCode }))
+		setPickerForEntry(null)
+	}
+
+	function removeFromSlot(slotKey: SlotKey) {
+		setSlots((prev) => ({ ...prev, [slotKey]: null }))
+	}
+
+	if (locked) {
+		if (!existingPrediction) {
+			return (
+				<Card>
+					<CardContent className="py-6 text-center text-muted-foreground">
+						Predictions are locked. You didn't submit one in time.
+					</CardContent>
+				</Card>
+			)
+		}
+		return (
+			<Card>
+				<CardHeader>
+					<CardTitle>Your Predictions (locked)</CardTitle>
+				</CardHeader>
+				<CardContent className="flex flex-col gap-2">
+					{SLOTS.map((slot) => {
+						const entry = findEntry(existingPrediction[slot.key])
+						return (
+							<div key={slot.key} className="flex items-center gap-2 rounded-md border p-2">
+								<span className="w-20 text-xs font-medium text-muted-foreground">{slot.label}</span>
+								<span className="text-sm">{entry ? formatEntry(entry) : "—"}</span>
+							</div>
+						)
+					})}
+				</CardContent>
+			</Card>
+		)
+	}
+
+	// Already submitted — show read-only with option to resubmit later
+	if (existingPrediction && allFilled) {
+		const hasChanges = SLOTS.some((s) => slots[s.key] !== existingPrediction[s.key])
+		if (!hasChanges) {
+			return (
+				<Card>
+					<CardHeader>
+						<CardTitle>Your Predictions (submitted)</CardTitle>
+					</CardHeader>
+					<CardContent className="flex flex-col gap-2">
+						{SLOTS.map((slot) => {
+							const entry = findEntry(existingPrediction[slot.key])
+							return (
+								<div key={slot.key} className="flex items-center justify-between rounded-md border p-2">
+									<div className="flex items-center gap-2">
+										<span className="w-20 text-xs font-medium text-muted-foreground">{slot.label}</span>
+										<span className="text-sm">{entry ? formatEntry(entry) : "—"}</span>
+									</div>
+									<button
+										type="button"
+										onClick={() => removeFromSlot(slot.key)}
+										className="text-xs text-muted-foreground hover:text-foreground"
+									>
+										change
+									</button>
+								</div>
+							)
+						})}
+					</CardContent>
+				</Card>
+			)
+		}
+	}
+
+	return (
+		<Card>
+			<CardHeader>
+				<CardTitle>Predictions</CardTitle>
+			</CardHeader>
+			<CardContent className="flex flex-col gap-4">
+				{/* Slot cards */}
+				<div className="flex flex-col gap-2">
+					{SLOTS.map((slot) => {
+						const code = slots[slot.key]
+						const entry = code ? findEntry(code) : null
+						return (
+							<div
+								key={slot.key}
+								className={`flex items-center justify-between rounded-md border p-2 ${
+									code ? "border-primary/30 bg-primary/5" : "border-dashed"
+								}`}
+							>
+								<div className="flex items-center gap-2">
+									<span className="w-20 text-xs font-medium text-muted-foreground">{slot.label}</span>
+									{entry ? (
+										<span className="text-sm">{formatEntry(entry)}</span>
+									) : (
+										<span className="text-sm text-muted-foreground">Tap an entry below</span>
+									)}
+								</div>
+								{code && (
+									<button
+										type="button"
+										onClick={() => removeFromSlot(slot.key)}
+										className="text-muted-foreground hover:text-foreground"
+										aria-label={`Remove ${slot.label}`}
+									>
+										✕
+									</button>
+								)}
+							</div>
+						)
+					})}
+				</div>
+
+				{/* Submit button */}
+				{allFilled && (
+					<Button
+						onClick={() =>
+							onSubmit({
+								first: slots.first!,
+								second: slots.second!,
+								third: slots.third!,
+								last: slots.last!,
+							})
+						}
+					>
+						{existingPrediction ? "Update Prediction" : "Submit Prediction"}
+					</Button>
+				)}
+
+				{/* Entry list */}
+				<div className="flex flex-col gap-1">
+					<h4 className="text-sm font-medium text-muted-foreground">Entries</h4>
+					{entries.map((entry) => {
+						const isAssigned = assignedCodes.has(entry.country.code)
+						const isPickerOpen = pickerForEntry === entry.country.code
+						return (
+							<div key={entry.country.code}>
+								<button
+									type="button"
+									disabled={isAssigned}
+									onClick={() => {
+										if (emptySlots.length === 1) {
+											assignToSlot(entry.country.code, emptySlots[0]!.key)
+										} else {
+											setPickerForEntry(isPickerOpen ? null : entry.country.code)
+										}
+									}}
+									className={`w-full rounded-md border px-3 py-2 text-left text-sm transition-colors ${
+										isAssigned
+											? "border-transparent bg-muted/50 text-muted-foreground line-through opacity-50"
+											: isPickerOpen
+												? "border-primary bg-primary/5"
+												: "hover:bg-muted"
+									}`}
+								>
+									{formatEntry(entry)}
+								</button>
+								{isPickerOpen && !isAssigned && (
+									<div className="mt-1 ml-4 flex gap-1">
+										{emptySlots.map((slot) => (
+											<button
+												type="button"
+												key={slot.key}
+												onClick={() => assignToSlot(entry.country.code, slot.key)}
+												className="rounded-md border px-2 py-1 text-xs hover:bg-primary hover:text-primary-foreground"
+											>
+												{slot.label}
+											</button>
+										))}
+									</div>
+								)}
+							</div>
+						)
+					})}
+				</div>
+			</CardContent>
+		</Card>
+	)
+}
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add packages/client/src/components/predictions-form.tsx
+git commit -m "rewrite predictions form as tap-to-assign with 4 ranked slots"
+```
+
+### Task 14: Update player list with prediction checkmark
+
+**Files:**
+- Modify: `packages/client/src/components/player-list.tsx`
+
+- [ ] **Step 1: Add predictionSubmitted prop and render checkmarks**
+
+Replace the entire file:
+
+```tsx
+import { Badge } from "@/components/ui/badge"
+import type { Player } from "@celebrate-esc/shared"
+
+interface PlayerListProps {
+	players: Player[]
+	mySessionId: string | null
+	predictionSubmitted?: Record<string, boolean>
+}
+
+export function PlayerList({ players, mySessionId, predictionSubmitted }: PlayerListProps) {
+	return (
+		<div className="flex flex-col gap-2">
+			<h3 className="text-sm font-medium text-muted-foreground">Players ({players.length})</h3>
+			<ul className="flex flex-col gap-1">
+				{players.map((player) => (
+					<li key={player.id} className="flex items-center gap-2">
+						<span
+							className={`h-2 w-2 rounded-full ${player.connected ? "bg-green-500" : "bg-muted"}`}
+						/>
+						<span className={player.sessionId === mySessionId ? "font-bold" : ""}>
+							{player.displayName}
+						</span>
+						{player.isHost && (
+							<Badge variant="secondary" className="text-xs">
+								Host
+							</Badge>
+						)}
+						{player.sessionId === mySessionId && (
+							<span className="text-xs text-muted-foreground">(you)</span>
+						)}
+						{predictionSubmitted?.[player.id] && (
+							<span className="text-green-600" title="Prediction submitted">✓</span>
+						)}
+					</li>
+				))}
+			</ul>
+		</div>
+	)
+}
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add packages/client/src/components/player-list.tsx
+git commit -m "add prediction submission checkmark to player list"
+```
+
+### Task 15: Update room header with new act labels
+
+**Files:**
+- Modify: `packages/client/src/components/room-header.tsx`
+
+- [ ] **Step 1: Use ACT_LABELS from shared constants**
+
+Replace the entire file:
+
+```tsx
+import { Badge } from "@/components/ui/badge"
+import { ACT_LABELS } from "@celebrate-esc/shared"
+import type { Act } from "@celebrate-esc/shared"
+
+interface RoomHeaderProps {
+	roomCode: string
+	currentAct: Act
+	connectionStatus: "disconnected" | "connecting" | "connected"
+}
+
+export function RoomHeader({ roomCode, currentAct, connectionStatus }: RoomHeaderProps) {
+	return (
+		<div className="flex items-center justify-between border-b p-4">
+			<div className="flex items-center gap-3">
+				<span className="font-mono text-2xl font-bold tracking-widest">{roomCode}</span>
+				<Badge variant="outline">{ACT_LABELS[currentAct]}</Badge>
+			</div>
+			<span
+				className={`h-2 w-2 rounded-full ${
+					connectionStatus === "connected"
+						? "bg-green-500"
+						: connectionStatus === "connecting"
+							? "bg-yellow-500"
+							: "bg-red-500"
+				}`}
+				title={connectionStatus}
+			/>
+		</div>
+	)
+}
+```
+
+- [ ] **Step 2: Commit**
+
+```bash
+git add packages/client/src/components/room-header.tsx
+git commit -m "use ACT_LABELS from shared constants in room header"
+```
+
+### Task 16: Update routes — remove dish UI, update act references
+
+**Files:**
+- Modify: `packages/client/src/routes/play.$roomCode.tsx`
+- Modify: `packages/client/src/routes/host.$roomCode.tsx`
+- Modify: `packages/client/src/routes/display.$roomCode.tsx`
+- Delete: `packages/client/src/components/dish-list.tsx`
+- Delete: `packages/client/src/components/dish-host.tsx`
+- Delete: `packages/client/src/components/dish-results.tsx`
+
+- [ ] **Step 1: Rewrite play.$roomCode.tsx**
+
+Replace the entire file:
+
+```tsx
+import { useEffect, useRef, useState } from "react"
+import { createFileRoute } from "@tanstack/react-router"
+import { useWebSocket } from "@/hooks/use-websocket"
+import { useRoomStore } from "@/stores/room-store"
+import { PlayerList } from "@/components/player-list"
+import { PredictionsForm } from "@/components/predictions-form"
+import { RoomHeader } from "@/components/room-header"
+import { Button } from "@/components/ui/button"
+import { Input } from "@/components/ui/input"
+
+export const Route = createFileRoute("/play/$roomCode")({
+	component: PlayerView,
+})
+
+function PlayerView() {
+	const { roomCode } = Route.useParams()
+	const { send } = useWebSocket(roomCode)
+	const { room, mySessionId, connectionStatus, gameState } = useRoomStore()
+	const joinSentRef = useRef(false)
+	const [manualName, setManualName] = useState("")
+
+	useEffect(() => {
+		if (connectionStatus !== "connected" || mySessionId || joinSentRef.current) return
+
+		const displayName = sessionStorage.getItem("esc-party-join-name")
+		if (displayName) {
+			joinSentRef.current = true
+			sessionStorage.removeItem("esc-party-join-name")
+			send({ type: "join_room", displayName })
+		}
+	}, [connectionStatus, mySessionId, send])
+
+	if (!room) {
+		return (
+			<div className="flex min-h-screen items-center justify-center">
+				<p className="text-muted-foreground">
+					{connectionStatus === "connecting" ? "Connecting..." : "Room not found"}
+				</p>
+			</div>
+		)
+	}
+
+	if (!mySessionId && connectionStatus === "connected" && !joinSentRef.current) {
+		return (
+			<div className="flex min-h-screen flex-col items-center justify-center gap-4 p-4">
+				<h2 className="text-xl font-bold">Join Room {roomCode}</h2>
+				<Input
+					placeholder="Your name"
+					value={manualName}
+					onChange={(e) => setManualName(e.target.value)}
+					maxLength={20}
+					onKeyDown={(e) => {
+						if (e.key === "Enter" && manualName.trim()) {
+							joinSentRef.current = true
+							send({ type: "join_room", displayName: manualName.trim() })
+						}
+					}}
+				/>
+				<Button
+					onClick={() => {
+						if (manualName.trim()) {
+							joinSentRef.current = true
+							send({ type: "join_room", displayName: manualName.trim() })
+						}
+					}}
+					disabled={!manualName.trim()}
+				>
+					Join
+				</Button>
+			</div>
+		)
+	}
+
+	if (!mySessionId) {
+		return (
+			<div className="flex min-h-screen items-center justify-center">
+				<p className="text-muted-foreground">Joining room...</p>
+			</div>
+		)
+	}
+
+	return (
+		<div className="flex min-h-screen flex-col">
+			<RoomHeader roomCode={roomCode} currentAct={room.currentAct} connectionStatus={connectionStatus} />
+			<div className="flex-1 p-4">
+				{room.currentAct === "lobby" && !gameState && (
+					<div className="flex flex-col items-center gap-4 py-8">
+						<p className="text-lg text-muted-foreground">Waiting for the host to start...</p>
+					</div>
+				)}
+
+				{gameState && room.currentAct !== "ended" && (
+					<div className="flex flex-col gap-4">
+						<PredictionsForm
+							entries={gameState.lineup.entries}
+							existingPrediction={gameState.myPrediction}
+							locked={gameState.predictionsLocked}
+							onSubmit={(prediction) =>
+								send({ type: "submit_prediction", ...prediction })
+							}
+						/>
+					</div>
+				)}
+
+				{room.currentAct === "ended" && (
+					<div className="flex flex-col items-center gap-4 py-8">
+						<p className="text-lg text-muted-foreground">The party has ended. Thanks for playing!</p>
+					</div>
+				)}
+
+				<PlayerList
+					players={room.players}
+					mySessionId={mySessionId}
+					predictionSubmitted={gameState?.predictionSubmitted}
+				/>
+			</div>
+		</div>
+	)
+}
+```
+
+- [ ] **Step 2: Rewrite host.$roomCode.tsx**
+
+Replace the entire file:
+
+```tsx
+import { createFileRoute } from "@tanstack/react-router"
+import { useWebSocket } from "@/hooks/use-websocket"
+import { useRoomStore } from "@/stores/room-store"
+import { PlayerList } from "@/components/player-list"
+import { PredictionsForm } from "@/components/predictions-form"
+import { RoomHeader } from "@/components/room-header"
+import { Button } from "@/components/ui/button"
+import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs"
+import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card"
+import type { Act } from "@celebrate-esc/shared"
+
+export const Route = createFileRoute("/host/$roomCode")({
+	component: HostView,
+})
+
+const nextActLabels: Partial<Record<Act, string>> = {
+	lobby: "Start Pre-Show",
+	"pre-show": "Start Live Event",
+	"live-event": "Start Scoring",
+	scoring: "End Party",
+}
+
+function HostView() {
+	const { roomCode } = Route.useParams()
+	const { send } = useWebSocket(roomCode)
+	const { room, mySessionId, connectionStatus, gameState } = useRoomStore()
+
+	if (!room) {
+		return (
+			<div className="flex min-h-screen items-center justify-center">
+				<p className="text-muted-foreground">
+					{connectionStatus === "connecting" ? "Connecting..." : "Room not found"}
+				</p>
+			</div>
+		)
+	}
+
+	return (
+		<div className="flex min-h-screen flex-col">
+			<RoomHeader roomCode={roomCode} currentAct={room.currentAct} connectionStatus={connectionStatus} />
+			<Tabs defaultValue="host" className="flex-1">
+				<TabsList className="w-full rounded-none">
+					<TabsTrigger value="play" className="flex-1">
+						Play
+					</TabsTrigger>
+					<TabsTrigger value="host" className="flex-1">
+						Host
+					</TabsTrigger>
+				</TabsList>
+				<TabsContent value="play" className="p-4">
+					{gameState && (room.currentAct === "lobby" || room.currentAct === "pre-show") && (
+						<div className="flex flex-col gap-4">
+							<PredictionsForm
+								entries={gameState.lineup.entries}
+								existingPrediction={gameState.myPrediction}
+								locked={gameState.predictionsLocked}
+								onSubmit={(prediction) =>
+									send({ type: "submit_prediction", ...prediction })
+								}
+							/>
+						</div>
+					)}
+					<PlayerList
+						players={room.players}
+						mySessionId={mySessionId}
+						predictionSubmitted={gameState?.predictionSubmitted}
+					/>
+				</TabsContent>
+				<TabsContent value="host" className="p-4">
+					<div className="flex flex-col gap-4">
+						<Card>
+							<CardHeader>
+								<CardTitle>Room Controls</CardTitle>
+							</CardHeader>
+							<CardContent className="flex flex-col gap-3">
+								{room.currentAct !== "ended" && (
+									<Button onClick={() => send({ type: "advance_act" })} className="w-full">
+										{nextActLabels[room.currentAct] ?? "Next"}
+									</Button>
+								)}
+								{room.currentAct !== "ended" && (
+									<Button
+										variant="destructive"
+										onClick={() => send({ type: "end_room" })}
+										className="w-full"
+									>
+										End Party
+									</Button>
+								)}
+								{room.currentAct === "ended" && (
+									<p className="text-center text-muted-foreground">
+										The party has ended. Thanks for playing!
+									</p>
+								)}
+							</CardContent>
+						</Card>
+						<PlayerList
+							players={room.players}
+							mySessionId={mySessionId}
+							predictionSubmitted={gameState?.predictionSubmitted}
+						/>
+					</div>
+				</TabsContent>
+			</Tabs>
+		</div>
+	)
+}
+```
+
+- [ ] **Step 3: Rewrite display.$roomCode.tsx — remove dishes, add copy-to-clipboard**
+
+Replace the entire file:
+
+```tsx
+import { useState } from "react"
+import { createFileRoute } from "@tanstack/react-router"
+import { useWebSocket } from "@/hooks/use-websocket"
+import { useRoomStore } from "@/stores/room-store"
+import { PlayerList } from "@/components/player-list"
+import { RoomHeader } from "@/components/room-header"
+import { ACT_LABELS } from "@celebrate-esc/shared"
+
+export const Route = createFileRoute("/display/$roomCode")({
+	component: DisplayView,
+})
+
+function DisplayView() {
+	const { roomCode } = Route.useParams()
+	useWebSocket(roomCode)
+	const { room, connectionStatus, gameState } = useRoomStore()
+
+	if (!room) {
+		return (
+			<div className="flex min-h-screen items-center justify-center">
+				<p className="text-muted-foreground">
+					{connectionStatus === "connecting" ? "Connecting..." : "Room not found"}
+				</p>
+			</div>
+		)
+	}
+
+	return (
+		<div className="flex min-h-screen flex-col">
+			<RoomHeader roomCode={roomCode} currentAct={room.currentAct} connectionStatus={connectionStatus} />
+			<div className="flex flex-1 flex-col items-center justify-center gap-8 p-8">
+				{room.currentAct === "lobby" && <LobbyDisplay roomCode={roomCode} />}
+
+				{room.currentAct === "pre-show" && gameState && (
+					<div className="flex flex-col items-center gap-4 py-12">
+						<p className="text-2xl text-muted-foreground">Pre-Show — Predictions</p>
+						<p className="text-lg text-muted-foreground">
+							{Object.values(gameState.predictionSubmitted).filter(Boolean).length} / {Object.keys(gameState.predictionSubmitted).length} predictions submitted
+						</p>
+					</div>
+				)}
+
+				{room.currentAct !== "lobby" && room.currentAct !== "ended" && room.currentAct !== "pre-show" && (
+					<div className="flex flex-col items-center gap-4 py-12">
+						<p className="text-2xl text-muted-foreground">{ACT_LABELS[room.currentAct]}</p>
+					</div>
+				)}
+
+				{room.currentAct === "ended" && (
+					<div className="flex flex-col items-center gap-4 py-12">
+						<p className="text-2xl text-muted-foreground">The party has ended. Thanks for playing!</p>
+					</div>
+				)}
+
+				<PlayerList
+					players={room.players}
+					mySessionId={null}
+					predictionSubmitted={gameState?.predictionSubmitted}
+				/>
+			</div>
+		</div>
+	)
+}
+
+function LobbyDisplay({ roomCode }: { roomCode: string }) {
+	const [copied, setCopied] = useState(false)
+	const base = import.meta.env.BASE_URL.replace(/\/$/, "")
+	const joinUrl = `${window.location.origin}${base}/play/${roomCode}`
+
+	function copyCode() {
+		navigator.clipboard.writeText(roomCode).then(() => {
+			setCopied(true)
+			setTimeout(() => setCopied(false), 2000)
+		})
+	}
+
+	return (
+		<div className="flex flex-col items-center gap-6">
+			<h2 className="text-2xl text-muted-foreground">Join the party!</h2>
+			<button
+				type="button"
+				onClick={copyCode}
+				className="cursor-pointer rounded-lg border-4 border-dashed border-muted p-8 transition-colors hover:border-primary/50"
+				title="Click to copy room code"
+			>
+				<span className="font-mono text-8xl font-bold tracking-[0.3em]">{roomCode}</span>
+			</button>
+			<p className="text-muted-foreground">
+				{copied ? (
+					<span className="font-medium text-green-600">Copied!</span>
+				) : (
+					<>Tap the code to copy</>
+				)}
+			</p>
+			<p className="text-muted-foreground">
+				Go to <span className="font-mono font-medium">{joinUrl}</span>
+			</p>
+		</div>
+	)
+}
+```
+
+- [ ] **Step 4: Delete dish components**
+
+```bash
+rm packages/client/src/components/dish-list.tsx
+rm packages/client/src/components/dish-host.tsx
+rm packages/client/src/components/dish-results.tsx
+```
+
+- [ ] **Step 5: Commit**
+
+```bash
+git add -u packages/client/src/components/dish-list.tsx packages/client/src/components/dish-host.tsx packages/client/src/components/dish-results.tsx
+git add packages/client/src/routes/play.\$roomCode.tsx packages/client/src/routes/host.\$roomCode.tsx packages/client/src/routes/display.\$roomCode.tsx
+git commit -m "update routes: remove dish UI, update act refs, add copy-to-clipboard on lobby display"
+```
+
+### Task 17: Final verification
+
+- [ ] **Step 1: Run all server tests**
+
+```bash
+cd packages/server && bun test
+```
+
+Expected: All tests pass (lineup tests updated for 2025, prediction tests use new 4-pick model, no dish tests remain).
+
+- [ ] **Step 2: Build the client**
+
+```bash
+cd packages/client && bun run build
+```
+
+Expected: Build succeeds with no errors. No imports of deleted dish components remain.
+
+- [ ] **Step 3: Build the shared package**
+
+```bash
+cd packages/shared && bun run build
+```
+
+Expected: Build succeeds.
+
+- [ ] **Step 4: Commit any remaining fixes**
+
+If any build/test issues were discovered and fixed, commit them now.