chore(release): 4.17.2 [skip ci]

## [4.17.2](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.17.1...v4.17.2) (2025-10-19) ### Bug Fixes * **tutorial:** correct column index calculation for variable column counts ([bf1ced4](bf1ced43f8))
fix(tutorial): correct column index calculation for variable column counts
2025-10-19 18:25:43 +00:00 · 2025-10-19 13:24:35 -05:00 · 2025-10-19 18:17:38 +00:00 · 2025-10-19 13:16:24 -05:00 · 2025-10-19 18:13:26 +00:00 · 2025-10-19 13:12:18 -05:00
38 changed files with 5899 additions and 1010 deletions
--- a/.github/workflows/deploy.yml
+++ b/.github/workflows/deploy.yml
@@ -57,6 +57,10 @@ jobs:
            type=ref,event=pr
            type=raw,value=latest,enable={{is_default_branch}}

+      - name: Get short commit SHA
+        id: vars
+        run: echo "short_sha=$(echo ${{ github.sha }} | cut -c1-8)" >> $GITHUB_OUTPUT
+
      - name: Build and push Docker image
        uses: docker/build-push-action@v5
        with:
@@ -64,3 +68,9 @@ jobs:
          push: true
          tags: ${{ steps.meta.outputs.tags }}
          labels: ${{ steps.meta.outputs.labels }}
+          build-args: |
+            GIT_COMMIT=${{ github.sha }}
+            GIT_COMMIT_SHORT=${{ steps.vars.outputs.short_sha }}
+            GIT_BRANCH=${{ github.ref_name }}
+            GIT_TAG=${{ github.ref_type == 'tag' && github.ref_name || '' }}
+            GIT_DIRTY=false
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -1,3 +1,300 @@
+## [4.17.2](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.17.1...v4.17.2) (2025-10-19)
+
+
+### Bug Fixes
+
+* **tutorial:** correct column index calculation for variable column counts ([bf1ced4](https://github.com/antialias/soroban-abacus-flashcards/commit/bf1ced43f801938b05f01548eea5fe771de1b58f))
+
+## [4.17.1](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.17.0...v4.17.1) (2025-10-19)
+
+
+### Bug Fixes
+
+* **tutorial:** filter bead highlights when using fewer columns ([4d906ec](https://github.com/antialias/soroban-abacus-flashcards/commit/4d906ec20e90a9b0b3838f9b8428e0c68992f381))
+
+## [4.17.0](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.16.0...v4.17.0) (2025-10-19)
+
+
+### Features
+
+* **tutorial:** add dark theme and column control props ([d42f9b2](https://github.com/antialias/soroban-abacus-flashcards/commit/d42f9b2d9ad630826c55b753dc581c469e8f9083))
+
+
+### Styles
+
+* **homepage:** soften tutorial styling for dark theme cohesion ([faaefba](https://github.com/antialias/soroban-abacus-flashcards/commit/faaefbacff419b337aa0fac4a101d5106a18c77c)), closes [#f9](https://github.com/antialias/soroban-abacus-flashcards/issues/f9)
+
+## [4.16.0](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.15.1...v4.16.0) (2025-10-19)
+
+
+### Features
+
+* **tutorial:** add hideNavigation prop to TutorialPlayer ([79ea52a](https://github.com/antialias/soroban-abacus-flashcards/commit/79ea52af80c8cbb482bbdd87f77caf32ada737ee))
+
+
+### Styles
+
+* **homepage:** update tutorial container to match dark theme ([6b017b0](https://github.com/antialias/soroban-abacus-flashcards/commit/6b017b0fe92d4277843d9fe2645c22366f219d76))
+
+## [4.15.1](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.15.0...v4.15.1) (2025-10-19)
+
+
+### Bug Fixes
+
+* **tutorial:** resolve React hydration error in TutorialPlayer ([c883d9e](https://github.com/antialias/soroban-abacus-flashcards/commit/c883d9e4c1b3a2f52c9d41e3ddce7418399f2649))
+
+
+### Code Refactoring
+
+* replace demo component with real TutorialPlayer system ([19b03bc](https://github.com/antialias/soroban-abacus-flashcards/commit/19b03bc77c649cf51d7b9a3617417c6ec8229ac7))
+
+## [4.15.0](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.14.6...v4.15.0) (2025-10-19)
+
+
+### Features
+
+* redesign homepage with educational vision and interactive demo ([2f09cb5](https://github.com/antialias/soroban-abacus-flashcards/commit/2f09cb5539f2bb0b8c77359c6f774c3742313e1e))
+
+## [4.14.6](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.14.5...v4.14.6) (2025-10-19)
+
+
+### Bug Fixes
+
+* replace native alerts with inline confirmations in ModerationPanel ([ebe123e](https://github.com/antialias/soroban-abacus-flashcards/commit/ebe123ed7edf24fbc7b8765ed709455a8513d6d5))
+
+
+### Documentation
+
+* add UI style guide documenting no native alerts rule ([9afd3a7](https://github.com/antialias/soroban-abacus-flashcards/commit/9afd3a7e925fddb76fa587747881b61f7cb077a5))
+
+## [4.14.5](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.14.4...v4.14.5) (2025-10-19)
+
+
+### Bug Fixes
+
+* **rooms:** add real-time ownership transfer updates via WebSocket ([c00cfa3](https://github.com/antialias/soroban-abacus-flashcards/commit/c00cfa3de011720f3399fa340182b347f7e0d456))
+
+## [4.14.4](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.14.3...v4.14.4) (2025-10-19)
+
+
+### Bug Fixes
+
+* **arcade:** add host-only game selection with clear messaging ([22df1b0](https://github.com/antialias/soroban-abacus-flashcards/commit/22df1b0b661efe69fac1a6bd716531c904757412))
+* **arcade:** add host-only game selection with clear messaging ([c0680ca](https://github.com/antialias/soroban-abacus-flashcards/commit/c0680cad0fa26af0933e93a06c50317bf443cc7d))
+
+## [4.14.3](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.14.2...v4.14.3) (2025-10-19)
+
+
+### Bug Fixes
+
+* **docker:** add qpdf for PDF linearization and validation ([c92ff39](https://github.com/antialias/soroban-abacus-flashcards/commit/c92ff3971c853e4e55ccd632ff3ee292fcce8315))
+
+## [4.14.2](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.14.1...v4.14.2) (2025-10-19)
+
+
+### Bug Fixes
+
+* **docker:** add packages/templates for Typst flashcard generation ([1417722](https://github.com/antialias/soroban-abacus-flashcards/commit/14177224380b8c37413123bee344c9b762055a15))
+
+## [4.14.1](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.14.0...v4.14.1) (2025-10-19)
+
+
+### Bug Fixes
+
+* **deployment:** pass git info to Docker build for deployment info modal ([4b04e43](https://github.com/antialias/soroban-abacus-flashcards/commit/4b04e43ff8c9e9f239d7f5e306aab338b535296f))
+
+## [4.14.0](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.13.15...v4.14.0) (2025-10-19)
+
+
+### Features
+
+* **card-sorting:** add spectator mode UX enhancements ([4ab093a](https://github.com/antialias/soroban-abacus-flashcards/commit/4ab093a9d8ba5b290da44aaa6aa71ad7d7149b32))
+
+
+### Documentation
+
+* **arcade:** add comprehensive spectator mode documentation ([1eb6cec](https://github.com/antialias/soroban-abacus-flashcards/commit/1eb6ceca19805be53dfe3194e07e68002b2d09a7))
+* **arcade:** spec spectator mode UX enhancements for card sorting ([aafba77](https://github.com/antialias/soroban-abacus-flashcards/commit/aafba77d62b47403f21f5dd72859d6a6fbb1efac))
+
+## [4.13.15](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.13.14...v4.13.15) (2025-10-19)
+
+
+### Bug Fixes
+
+* **docker:** bypass PEP 668 externally-managed-environment error ([bb59c61](https://github.com/antialias/soroban-abacus-flashcards/commit/bb59c61638e60b0678043e954e044d9390f88e7f))
+
+## [4.13.14](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.13.13...v4.13.14) (2025-10-19)
+
+
+### Bug Fixes
+
+* **docker:** install py3-pip for Python dependency installation ([0f55909](https://github.com/antialias/soroban-abacus-flashcards/commit/0f55909533414bdc07f113b93bb8bfa21367959b))
+
+
+### Documentation
+
+* add Panda CSS styling framework documentation ([c92d7d9](https://github.com/antialias/soroban-abacus-flashcards/commit/c92d7d9d89a72e012c30fc5ac88fa96e7a526f83))
+* **arcade:** fix incorrect Tailwind references - use Panda CSS ([34a377d](https://github.com/antialias/soroban-abacus-flashcards/commit/34a377d91b37ad47968b85aedd112f9fcf72ad63))
+
+## [4.13.13](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.13.12...v4.13.13) (2025-10-19)
+
+
+### Bug Fixes
+
+* **docker:** install Python dependencies for flashcard generation ([c9b7e92](https://github.com/antialias/soroban-abacus-flashcards/commit/c9b7e92f39ee7aa7f13606c2836763144df102e7))
+
+
+### Code Refactoring
+
+* **arcade:** standardize game card themes with preset system ([0209975](https://github.com/antialias/soroban-abacus-flashcards/commit/0209975af642944cc5a434c0b44205a87e634e7e)), closes [#99f6e4](https://github.com/antialias/soroban-abacus-flashcards/issues/99f6e4) [#5eead4](https://github.com/antialias/soroban-abacus-flashcards/issues/5eead4)
+
+## [4.13.12](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.13.11...v4.13.12) (2025-10-18)
+
+
+### Bug Fixes
+
+* **card-sorting:** use blue gradient matching other game cards ([bdb84f5](https://github.com/antialias/soroban-abacus-flashcards/commit/bdb84f5d909542060fa886a83a5af62c4a785a98))
+
+## [4.13.11](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.13.10...v4.13.11) (2025-10-18)
+
+
+### Bug Fixes
+
+* **card-sorting:** match game selector background to other games ([db62519](https://github.com/antialias/soroban-abacus-flashcards/commit/db62519f9beb0b4bc6120e1fd5ec251cfde5c3c1)), closes [#ccfbf1](https://github.com/antialias/soroban-abacus-flashcards/issues/ccfbf1) [#99f6e4](https://github.com/antialias/soroban-abacus-flashcards/issues/99f6e4)
+* **docker:** copy core package with Python scripts to production image ([33e9ad2](https://github.com/antialias/soroban-abacus-flashcards/commit/33e9ad2f79b591f1c5ee57a6691e1bcf48420859))
+
+## [4.13.10](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.13.9...v4.13.10) (2025-10-18)
+
+
+### Bug Fixes
+
+* add Typst to Docker image for flashcard generation ([d9a7694](https://github.com/antialias/soroban-abacus-flashcards/commit/d9a769403187bf70fb069be7ffe77417a62271a5))
+
+
+### Code Refactoring
+
+* remove 'Complete Soroban Learning Platform' section ([42dcbff](https://github.com/antialias/soroban-abacus-flashcards/commit/42dcbff85708ad378550634cbf7a3345eccb578e))
+
+## [4.13.9](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.13.8...v4.13.9) (2025-10-18)
+
+
+### Bug Fixes
+
+* set color on abacus container div for numeral visibility ([cd47960](https://github.com/antialias/soroban-abacus-flashcards/commit/cd4796024e41f731ae5d83c82f6582e19d6eaf99)), closes [#1f2937](https://github.com/antialias/soroban-abacus-flashcards/issues/1f2937)
+
+## [4.13.8](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.13.7...v4.13.8) (2025-10-18)
+
+
+### Bug Fixes
+
+* use color instead of fill for numeral styling ([ea10c16](https://github.com/antialias/soroban-abacus-flashcards/commit/ea10c16811eb969b9963417079c330ae9ff295ba))
+
+## [4.13.7](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.13.6...v4.13.7) (2025-10-18)
+
+
+### Bug Fixes
+
+* add dark color for abacus numerals ([73ff32c](https://github.com/antialias/soroban-abacus-flashcards/commit/73ff32c2432beb62710e57aa8b3b4793eca43fda)), closes [#1f2937](https://github.com/antialias/soroban-abacus-flashcards/issues/1f2937)
+* use app-wide abacus config and remove instruction text ([0a50c73](https://github.com/antialias/soroban-abacus-flashcards/commit/0a50c733b089c7c341f0fdef47da78d1c61a3cb5))
+
+## [4.13.6](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.13.5...v4.13.6) (2025-10-18)
+
+
+### Bug Fixes
+
+* simplify abacus pane with light background ([30f48ab](https://github.com/antialias/soroban-abacus-flashcards/commit/30f48ab8976976688e089b07ece7fdae6d7ada79))
+
+## [4.13.5](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.13.4...v4.13.5) (2025-10-18)
+
+
+### Bug Fixes
+
+* correct AbacusReact API usage and add structural styling ([247377f](https://github.com/antialias/soroban-abacus-flashcards/commit/247377fca35ee3433e02ad594ecc1c4f391f0143)), closes [#fbbf24](https://github.com/antialias/soroban-abacus-flashcards/issues/fbbf24) [#a78](https://github.com/antialias/soroban-abacus-flashcards/issues/a78)
+
+## [4.13.4](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.13.3...v4.13.4) (2025-10-18)
+
+
+### Bug Fixes
+
+* **card-sorting:** increase card tile sizes to contain abacuses ([d2a3b7a](https://github.com/antialias/soroban-abacus-flashcards/commit/d2a3b7ae2e3f6819b8d9ace32be22f04f748d1bc))
+
+## [4.13.3](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.13.2...v4.13.3) (2025-10-18)
+
+
+### Bug Fixes
+
+* **card-sorting:** increase SVG size to fill card containers ([cf9d893](https://github.com/antialias/soroban-abacus-flashcards/commit/cf9d893f3fdbef6e91cd0ba283d602b9215569f1))
+
+## [4.13.2](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.13.1...v4.13.2) (2025-10-18)
+
+
+### Bug Fixes
+
+* show initial value and improve numeral contrast ([1b57f6d](https://github.com/antialias/soroban-abacus-flashcards/commit/1b57f6ddecf3a118f2e4fadd1a91be1256f5a034)), closes [#fbbf24](https://github.com/antialias/soroban-abacus-flashcards/issues/fbbf24)
+
+## [4.13.1](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.13.0...v4.13.1) (2025-10-18)
+
+
+### Bug Fixes
+
+* use defaultValue for interactive abacus control ([06aca98](https://github.com/antialias/soroban-abacus-flashcards/commit/06aca986ace4d76b70f2fd2f5e57f66758185b38))
+
+## [4.13.0](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.12.0...v4.13.0) (2025-10-18)
+
+
+### Features
+
+* make home page abacus interactive with audio ([9a53d7e](https://github.com/antialias/soroban-abacus-flashcards/commit/9a53d7e5db18853aca4e2e0c7abc799217feaecf))
+
+## [4.12.0](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.11.1...v4.12.0) (2025-10-18)
+
+
+### Features
+
+* redesign home page with component showcase ([29af265](https://github.com/antialias/soroban-abacus-flashcards/commit/29af265958f9fdab0253b92e153c01575840454d))
+
+## [4.11.1](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.11.0...v4.11.1) (2025-10-18)
+
+
+### Bug Fixes
+
+* **card-sorting:** center AbacusReact SVGs in card tiles ([26edec1](https://github.com/antialias/soroban-abacus-flashcards/commit/26edec1bbf038264405ec9d161edcd18f67a6fc6))
+
+## [4.11.0](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.10.6...v4.11.0) (2025-10-18)
+
+
+### Features
+
+* **home:** redesign home page to showcase complete platform ([ee6c4f2](https://github.com/antialias/soroban-abacus-flashcards/commit/ee6c4f2f4f39e3b30f59c54866c3857c218fb80f))
+
+## [4.10.6](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.10.5...v4.10.6) (2025-10-18)
+
+
+### Bug Fixes
+
+* **card-sorting:** position slots flow horizontally with wrap ([e14ffe4](https://github.com/antialias/soroban-abacus-flashcards/commit/e14ffe44d66d0c97bc0cc4e0c255698e88ce723a))
+
+## [4.10.5](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.10.4...v4.10.5) (2025-10-18)
+
+
+### Code Refactoring
+
+* **arcade:** merge /arcade/room into /arcade route ([0790074](https://github.com/antialias/soroban-abacus-flashcards/commit/0790074ffc5008bce9a162fe0ddbd1d5c214c4f7))
+
+## [4.10.4](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.10.3...v4.10.4) (2025-10-18)
+
+
+### Bug Fixes
+
+* **card-sorting:** match Python card layout with flex wrap ([9679d68](https://github.com/antialias/soroban-abacus-flashcards/commit/9679d68154ac8b6a2f905ec7d17a34b39bc00237))
+
+## [4.10.3](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.10.2...v4.10.3) (2025-10-18)
+
+
+### Bug Fixes
+
+* **arcade:** remove broken query param from game URLs ([87631af](https://github.com/antialias/soroban-abacus-flashcards/commit/87631af6788bd7b42e671374e55ec0ad8435900c))
+
 ## [4.10.2](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.10.1...v4.10.2) (2025-10-18)


--- a/28
+++ b/28
@@ -21,6 +21,21 @@ RUN pnpm install --frozen-lockfile

 # Builder stage
 FROM base AS builder
+
+# Accept git information as build arguments
+ARG GIT_COMMIT
+ARG GIT_COMMIT_SHORT
+ARG GIT_BRANCH
+ARG GIT_TAG
+ARG GIT_DIRTY
+
+# Set as environment variables for build scripts
+ENV GIT_COMMIT=${GIT_COMMIT}
+ENV GIT_COMMIT_SHORT=${GIT_COMMIT_SHORT}
+ENV GIT_BRANCH=${GIT_BRANCH}
+ENV GIT_TAG=${GIT_TAG}
+ENV GIT_DIRTY=${GIT_DIRTY}
+
 COPY . .

 # Generate Panda CSS styled-system before building
@@ -33,8 +48,8 @@ RUN turbo build --filter=@soroban/web
 FROM node:18-alpine AS runner
 WORKDIR /app

-# Install Python and build tools for better-sqlite3 (needed at runtime)
-RUN apk add --no-cache python3 py3-setuptools make g++
+# Install Python, pip, build tools for better-sqlite3, Typst, and qpdf (needed at runtime)
+RUN apk add --no-cache python3 py3-pip py3-setuptools make g++ typst qpdf

 # Create non-root user
 RUN addgroup --system --gid 1001 nodejs
@@ -55,6 +70,15 @@ COPY --from=builder --chown=nextjs:nodejs /app/apps/web/drizzle ./apps/web/drizz
 COPY --from=builder --chown=nextjs:nodejs /app/node_modules ./node_modules
 COPY --from=builder --chown=nextjs:nodejs /app/apps/web/node_modules ./apps/web/node_modules

+# Copy core package (needed for Python flashcard generation scripts)
+COPY --from=builder --chown=nextjs:nodejs /app/packages/core ./packages/core
+
+# Copy templates package (needed for Typst templates)
+COPY --from=builder --chown=nextjs:nodejs /app/packages/templates ./packages/templates
+
+# Install Python dependencies for flashcard generation
+RUN pip3 install --no-cache-dir --break-system-packages -r packages/core/requirements.txt
+
 # Copy package.json files for module resolution
 COPY --from=builder --chown=nextjs:nodejs /app/package.json ./
 COPY --from=builder --chown=nextjs:nodejs /app/apps/web/package.json ./apps/web/
--- a/apps/web/.claude/ARCADE_ARCHITECTURE.md
+++ b/apps/web/.claude/ARCADE_ARCHITECTURE.md
@@ -16,6 +16,7 @@ Following `docs/terminology-user-player-room.md`:
 - **PLAYER ROSTER** - All PLAYERS belonging to a USER (can have many)
 - **ACTIVE PLAYERS** - PLAYERS where `isActive = true` - these are the ones that actually participate in games
 - **ROOM MEMBER** - A USER's participation in a multiplayer room (tracked in `room_members` table)
+- **SPECTATOR** - A room member who watches another player's game without participating (see Spectator Mode section)

 **Important:** A USER can have many PLAYERS in their roster, but only the ACTIVE PLAYERS (where `isActive = true`) participate in games. This enables "hot-potato" style local multiplayer where multiple people share the same device. This is LOCAL play (not networked), even though multiple PLAYERS participate.

@@ -27,25 +28,46 @@ In arcade sessions:

 ## Critical Architectural Requirements

-### 1. Mode Isolation (MUST ENFORCE)
+### 1. Game Synchronization Modes

-**Local Play** (`/arcade/[game-name]`)
+The arcade system supports three synchronization patterns:
+
+#### Local Play (No Network Sync)
+**Route**: Custom route or dedicated local page
+**Use Case**: Practice, offline play, or games that should never be visible to others

 - MUST NOT sync game state across the network
 - MUST NOT use room data, even if the USER is currently a member of an active room
- MUST create isolated, per-USER game sessions
+- MUST pass `roomId: undefined` to `useArcadeSession`
 - Game state lives only in the current browser tab/session
 - CAN have multiple ACTIVE PLAYERS from the same USER (local multiplayer / hot-potato)
 - State is NOT shared across the network, only within the browser session

-**Room-Based Play** (`/arcade/room`)
+#### Room-Based with Spectator Mode (RECOMMENDED PATTERN)
+**Route**: `/arcade/room` (or use room context anywhere)
+**Use Case**: Most arcade games - enables spectating even for single-player games

- MUST sync game state across all room members via network
- MUST use the USER's current active room
- MUST coordinate moves via server WebSocket
+- SYNCS game state across all room members via network
+- Uses the USER's current active room (`roomId: roomData?.id`)
+- Coordinates moves via server WebSocket
 - Game state is shared across all ACTIVE PLAYERS from all USERS in the room
- When a PLAYER makes a move, all room members see it in real-time
- CAN ALSO have multiple ACTIVE PLAYERS per USER (networked + local multiplayer combined)
+- **Non-playing room members become SPECTATORS** (see Spectator Mode section)
+- When a PLAYER makes a move, all room members see it in real-time (players + spectators)
+- CAN have multiple ACTIVE PLAYERS per USER (networked + local multiplayer combined)
+
+**✅ This is the PREFERRED pattern** - even for single-player games like Card Sorting, because:
+- Enables spectator mode automatically
+- Creates social experience ("watch me solve this!")
+- No extra code needed
+- Works seamlessly with multiplayer games too
+
+#### Pure Multiplayer (Room-Only)
+**Route**: `/arcade/room` with validation
+**Use Case**: Games that REQUIRE multiple players (e.g., competitive battles)
+
+- Same as Room-Based with Spectator Mode
+- Plus: Validates minimum player count before starting
+- Plus: May prevent game start if `activePlayers.length < minPlayers`

 ### 2. Room ID Usage Rules

@@ -258,6 +280,327 @@ sendMove({
   - Mode: Room-based play (roomId: "room_xyz")
   - 5 total active PLAYERS across 2 devices, all synced over network

+5. **Single-player game with spectators (Card Sorting):**
+   - USER A: "guest_abc"
+     - Active PLAYERS: ["player_001"]
+     - Playing Card Sorting Challenge
+   - USER B: "guest_def"
+     - Active PLAYERS: [] (none selected)
+     - Spectating USER A's game
+   - USER C: "guest_ghi"
+     - Active PLAYERS: ["player_005"]
+     - Spectating USER A's game (could play after USER A finishes)
+   - Mode: Room-based play (roomId: "room_xyz")
+   - All room members see USER A's card placements in real-time
+   - Spectators cannot interact with the game state
+
+## Spectator Mode
+
+### Overview
+
+Spectator mode is automatically enabled when using room-based sync (`roomId: roomData?.id`). Any room member who is not actively playing becomes a spectator and can watch the game in real-time.
+
+**Key Benefits**:
+- Creates social/collaborative experience even for single-player games
+- "Watch me solve this!" engagement
+- Learning by observation
+- Cheering/coaching opportunity
+- No extra implementation needed
+
+### How It Works
+
+1. **Automatic Role Assignment**:
+   - Room members with active PLAYERs in the game → **Players**
+   - Room members without active PLAYERs in the game → **Spectators**
+
+2. **State Synchronization**:
+   - All game state updates broadcast to entire room via `game:${roomId}` socket room
+   - Spectators receive same state updates as players
+   - Spectators see game in real-time as it happens
+
+3. **Interaction Control**:
+   - Players can make moves (send move actions)
+   - Spectators can only observe (no move actions permitted)
+   - Server validates PLAYER ownership before accepting moves
+
+### Implementation Pattern
+
+**Provider** (Room-Based with Spectator Support):
+
+```typescript
+export function CardSortingProvider({ children }: { children: ReactNode }) {
+  const { data: viewerId } = useViewerId()
+  const { roomData } = useRoomData()  // ✅ Fetch room data
+  const { activePlayers, players } = useGameMode()
+
+  // Find local player (if any)
+  const localPlayerId = useMemo(() => {
+    return Array.from(activePlayers).find((id) => {
+      const player = players.get(id)
+      return player?.isLocal !== false
+    })
+  }, [activePlayers, players])
+
+  const { state, sendMove, exitSession } = useArcadeSession<CardSortingState>({
+    userId: viewerId || '',
+    roomId: roomData?.id,  // ✅ Enable spectator mode
+    initialState,
+    applyMove: applyMoveOptimistically,
+  })
+
+  // Actions check if local player exists before allowing moves
+  const startGame = useCallback(() => {
+    if (!localPlayerId) {
+      console.warn('[CardSorting] No local player - spectating only')
+      return  // ✅ Spectators cannot start game
+    }
+    sendMove({ type: 'START_GAME', playerId: localPlayerId, ... })
+  }, [localPlayerId, sendMove])
+
+  // ... rest of provider
+}
+```
+
+**Key Implementation Points**:
+- Always check `if (!localPlayerId)` before allowing moves
+- Return early or show "Spectating..." message
+- Don't throw errors - spectating is a valid state
+- UI should indicate spectator vs player role
+
+### UI/UX Considerations
+
+#### 1. Spectator Indicators
+
+Show visual feedback when user is spectating:
+
+```typescript
+{!localPlayerId && state.gamePhase === 'playing' && (
+  <div className={spectatorBannerStyles}>
+    👀 Spectating {state.playerMetadata.name}'s game
+  </div>
+)}
+```
+
+#### 2. Disabled Controls
+
+Disable interactive elements for spectators:
+
+```typescript
+<button
+  onClick={placeCard}
+  disabled={!localPlayerId}  // Spectators can't interact
+  className={css({
+    opacity: !localPlayerId ? 0.5 : 1,
+    cursor: !localPlayerId ? 'not-allowed' : 'pointer',
+  })}
+>
+  Place Card
+</button>
+```
+
+#### 3. Join Prompt
+
+For games that support multiple players, show "Join Game" option:
+
+```typescript
+{!localPlayerId && state.gamePhase === 'setup' && (
+  <button onClick={selectPlayerAndJoin}>
+    Join as Player
+  </button>
+)}
+```
+
+#### 4. Real-Time Updates
+
+Ensure spectators see smooth updates:
+- Use optimistic UI updates (same as players)
+- Show animations for state changes
+- Display current player's moves as they happen
+
+### When to Use Spectator Mode
+
+**✅ Use Spectator Mode (room-based sync) For**:
+- Single-player puzzle games (Card Sorting, Sudoku, etc.)
+- Turn-based competitive games (Matching Pairs Battle)
+- Cooperative games (Memory Lightning)
+- Any game where watching is educational/entertaining
+- Social/family game nights
+- Classroom settings (teacher demonstrates, students watch)
+
+**❌ Avoid Spectator Mode (use local-only) For**:
+- Private practice sessions
+- Timed competitive games where watching gives unfair advantage
+- Games with personal/sensitive content
+- Offline/no-network scenarios
+- Performance-critical games (reduce network overhead)
+
+### Example Scenarios
+
+#### Scenario 1: Family Game Night - Card Sorting
+
+```
+Room: "Smith Family Game Night"
+
+USER A (Dad): Playing Card Sorting
+  - Active PLAYER: "Dad 👨"
+  - State: Placing cards, 6/8 complete
+  - Can interact with game
+
+USER B (Mom): Spectating
+  - Active PLAYERS: [] (none selected)
+  - State: Sees Dad's card placements in real-time
+  - Cannot place cards
+  - Can cheer and help
+
+USER C (Kid): Spectating
+  - Active PLAYER: "Emma 👧" (selected but not in this game)
+  - State: Watching to learn strategy
+  - Will play next round
+
+Flow:
+1. Dad starts Card Sorting
+2. Mom and Kid see setup phase
+3. Dad places cards one by one
+4. Mom/Kid see each placement instantly
+5. Dad checks solution
+6. Everyone sees the score together
+7. Kid says "My turn!" and starts their own game
+8. Dad and Mom become spectators
+```
+
+#### Scenario 2: Classroom - Memory Lightning
+
+```
+Room: "Ms. Johnson's 3rd Grade"
+
+USER A (Teacher): Playing cooperatively with 2 students
+  - Active PLAYERS: ["Teacher 👩‍🏫", "Student 1 👦"]
+  - State: Memorizing cards
+  - Both can participate
+
+USER B-F (5 other students): Spectating
+  - Watching demonstration
+  - Learning the rules
+  - Will join next round
+
+Flow:
+1. Teacher demonstrates with 2 students
+2. Other students watch and learn
+3. Round ends
+4. Teacher sets up new round
+5. New students join as players
+6. Previous players become spectators
+```
+
+### Server-Side Handling
+
+The server must handle spectators correctly:
+
+```typescript
+// Validate move ownership
+socket.on('game-move', ({ move, roomId }) => {
+  const session = getSession(roomId)
+
+  // Check if PLAYER making move is in the active players list
+  if (!session.activePlayers.includes(move.playerId)) {
+    return {
+      error: 'PLAYER not in game - spectators cannot make moves'
+    }
+  }
+
+  // Check if USER owns this PLAYER
+  const playerOwner = getPlayerOwner(move.playerId)
+  if (playerOwner !== socket.userId) {
+    return {
+      error: 'USER does not own this PLAYER'
+    }
+  }
+
+  // Valid move - apply and broadcast
+  const newState = validator.validateMove(session.state, move)
+  io.to(`game:${roomId}`).emit('state-update', newState)  // ALL room members get update
+})
+```
+
+**Key Server Logic**:
+- Validate PLAYER is in `session.activePlayers`
+- Validate USER owns PLAYER
+- Broadcast to entire room (players + spectators)
+- Spectators receive updates but cannot send moves
+
+### Testing Spectator Mode
+
+```typescript
+describe('Spectator Mode', () => {
+  it('should allow room members to spectate single-player games', () => {
+    // Setup: USER A and USER B in same room
+    // Action: USER A starts Card Sorting (single-player)
+    // Assert: USER B receives game state updates
+    // Assert: USER B cannot make moves
+    // Assert: USER B sees USER A's card placements in real-time
+  })
+
+  it('should prevent spectators from making moves', () => {
+    // Setup: USER A playing, USER B spectating
+    // Action: USER B attempts to place a card
+    // Assert: Server rejects move (PLAYER not in activePlayers)
+    // Assert: Client UI disables controls for USER B
+  })
+
+  it('should show spectator indicator in UI', () => {
+    // Setup: USER B spectating USER A's game
+    // Assert: UI shows "Spectating [Player Name]" banner
+    // Assert: Interactive controls are disabled
+    // Assert: Game state is visible
+  })
+
+  it('should allow spectator to join next round', () => {
+    // Setup: USER B spectating USER A's Card Sorting game
+    // Action: USER A finishes game, returns to setup
+    // Action: USER B starts new game
+    // Assert: USER A becomes spectator
+    // Assert: USER B becomes active player
+  })
+})
+```
+
+### Migration Path
+
+**For existing games**:
+
+If your game currently uses `roomId: roomData?.id`, it already supports spectator mode! You just need to:
+
+1. ✅ Check for `!localPlayerId` before allowing moves
+2. ✅ Add spectator UI indicators
+3. ✅ Disable controls when spectating
+4. ✅ Test spectator experience
+
+**Example Fix**:
+
+```typescript
+// Before (will crash for spectators)
+const placeCard = useCallback((cardId, position) => {
+  sendMove({
+    type: 'PLACE_CARD',
+    playerId: localPlayerId,  // ❌ Will be undefined for spectators!
+    ...
+  })
+}, [localPlayerId, sendMove])
+
+// After (spectator-safe)
+const placeCard = useCallback((cardId, position) => {
+  if (!localPlayerId) {
+    console.warn('Spectators cannot place cards')
+    return  // ✅ Spectators blocked from moving
+  }
+  sendMove({
+    type: 'PLACE_CARD',
+    playerId: localPlayerId,
+    ...
+  })
+}, [localPlayerId, sendMove])
+```
+
 ## Common Mistakes to Avoid

 ### Mistake 1: Conditional Room Usage
--- a/apps/web/.claude/ARCADE_ROUTING_ARCHITECTURE.md
+++ b/apps/web/.claude/ARCADE_ROUTING_ARCHITECTURE.md
@@ -0,0 +1,440 @@
+# Arcade Routing Architecture - Complete Overview
+
+## 1. Current /arcade Page
+
+**File:** `/Users/antialias/projects/soroban-abacus-flashcards/apps/web/src/app/arcade/page.tsx` (lines 1-129)
+
+**Purpose:** The main arcade landing page - displays the "Champion Arena"
+
+**Key Components:**
+- `ArcadeContent()` - Renders the main arcade interface
+  - Uses `EnhancedChampionArena` component which contains `GameSelector`
+  - The `GameSelector` displays all available games as cards
+  - `GameSelector` includes both legacy games and registry games
+  
+**Current Flow:**
+1. User navigates to `/arcade`
+2. Page renders `FullscreenProvider` wrapper
+3. Displays `PageWithNav` with title "🏟️ Champion Arena"
+4. Content area shows `EnhancedChampionArena` → `GameSelector`
+5. `GameSelector` renders `GameCard` components for each game
+6. When user clicks a game card, `GameCard` calls `router.push(config.url)`
+7. For registry games, `config.url` is `/arcade/room?game={gameName}`
+8. For legacy games, URL would be direct to their page
+
+**State Management:**
+- `GameModeContext` provides player selection (emoji, name, color)
+- `PageWithNav` wraps content and provides mini-nav with:
+  - Active player list
+  - Add player button
+  - Game mode indicator (single/battle/tournament)
+  - Exit session handler
+
+## 2. Current /arcade/room Page
+
+**File:** `/Users/antialias/projects/soroban-abacus-flashcards/apps/web/src/app/arcade/room/page.tsx` (lines 1-359)
+
+**Purpose:** "Magical place" that shows either a game OR the game chooser, driven by room state
+
+**Three States:**
+
+### State 1: Loading
+- Shows "Loading room..." message
+- Waits for `useRoomData()` hook to resolve
+
+### State 2: Game Selection UI (when `!roomData.gameName`)
+- Shows large game selection buttons
+- User clicks to select a game
+- Calls `setRoomGame()` mutation to save selection to room
+- Invokes `handleGameSelect()` which:
+  1. Checks if game exists in registry via `hasGame(gameType)`
+  2. If registry game: calls `setRoomGame({roomId, gameName: gameType})`
+  3. If legacy game: maps to internal name via `GAME_TYPE_TO_NAME`, then calls `setRoomGame()`
+  4. Game selection is persisted to the room database
+
+### State 3: Game Display (when `roomData.gameName` is set)
+- Checks game registry first via `hasGame(roomData.gameName)`
+- If registry game: 
+  - Gets game definition via `getGame(roomData.gameName)`
+  - Renders: `<Provider><GameComponent /></Provider>`
+  - Provider and GameComponent come from game registry definition
+- If legacy game:
+  - Switch statement with TODO for individual games
+  - Currently only shows "Game not yet supported"
+
+**Key Hook:**
+- `useRoomData()` - Fetches current room from API and subscribes to socket updates
+  - Returns `roomData` with fields: `id`, `name`, `code`, `gameName`, `gameConfig`, `members`, `memberPlayers`
+  - Also returns `isLoading` boolean
+
+**Navigation Flow:**
+1. User navigates to `/arcade`
+2. `GameCard` onClick calls `router.push('/arcade/room?game={gameName}')`
+3. User arrives at `/arcade/room`
+4. If NOT in a room yet: Shows error with link back to `/arcade`
+5. If in room but no game selected: Shows game selection UI
+6. If game selected: Loads and displays game
+
+## 3. The "Mini App Nav" - GameContextNav Component
+
+**File:** `/Users/antialias/projects/soroban-abacus-flashcards/apps/web/src/components/nav/GameContextNav.tsx` (lines 1-372)
+
+**What It Is:**
+The "mini app nav" is actually a sophisticated component within the `PageWithNav` wrapper that intelligently shows different UI based on context:
+
+**Components & Props:**
+- `navTitle` - Current page title (e.g., "Champion Arena", "Choose Game", "Speed Complement Race")
+- `navEmoji` - Icon emoji for current page
+- `gameMode` - Computed from active player count: 'none' | 'single' | 'battle' | 'tournament'
+- `activePlayers` - Array of selected players
+- `inactivePlayers` - Array of available but unselected players
+- `shouldEmphasize` - Boolean to emphasize player selection
+- `showFullscreenSelection` - Boolean to show fullscreen mode for player selection
+- `roomInfo` - Optional arcade room data (roomId, roomName, gameName, playerCount, joinCode)
+- `networkPlayers` - Remote players from room members
+
+**Three Display Modes:**
+
+### Mode 1: Fullscreen Player Selection
+- When `showFullscreenSelection === true`
+- Displays:
+  - Large title with emoji
+  - Game mode indicator
+  - Fullscreen player selection UI
+  - Shows all inactive players for selection
+
+### Mode 2: Solo Mode (NOT in room)
+- When `roomInfo` is undefined
+- Shows:
+  - **Game Title Section** (left side):
+    - `GameTitleMenu` with game title and emoji
+    - Menu options: Setup, New Game, Quit
+    - `GameModeIndicator`
+  - **Player Section** (right side):
+    - `ActivePlayersList` - shows selected players
+    - `AddPlayerButton` - add more players
+
+### Mode 3: Room Mode (IN a room)
+- When `roomInfo` is defined
+- Shows:
+  - **Hidden:** Game title section (display: none)
+  - **Room Info Pane** (left side):
+    - `RoomInfo` component with room details
+    - Game mode indicator with color/emoji
+    - Room name, player count, join code
+    - `NetworkPlayerIndicator` components for remote players
+  - **Player Section** (may be hidden):
+    - Shows local active players
+    - Add player button (for local players only)
+
+**Key Sub-Components:**
+- `GameTitleMenu` - Menu for game options (setup, new game, quit)
+- `GameModeIndicator` - Shows 🎯 Solo, ⚔️ Battle, 🏆 Tournament, 👥 Select
+- `RoomInfo` - Displays room metadata
+- `NetworkPlayerIndicator` - Shows remote players with scores/streaks
+- `ActivePlayersList` - List of selected players
+- `AddPlayerButton` - Button to add more players with popover
+- `FullscreenPlayerSelection` - Large player picker for fullscreen mode
+- `PendingInvitations` - Banner for room invitations
+
+**State Management:**
+- Lifted from `PageWithNav` to preserve state across remounts:
+  - `showPopover` / `setShowPopover` - AddPlayerButton popover state
+  - `activeTab` / `setActiveTab` - 'add' or 'invite' tab selection
+
+## 4. Navigation Flow
+
+### Flow 1: Solo Player → Game Selection → Room Creation → Game Start
+
+```
+/arcade (Champion Arena)
+  ↓ [Select players - updates GameModeContext]
+  ↓ [Click game card - GameCard.onClick → router.push]
+/arcade/room (if not in room, shows game selector)
+  ↓ [Select game - calls setRoomGame mutation]
+  ↓ [Room created, gameName saved to roomData]
+  ↓ [useRoomData refetch updates roomData.gameName]
+/arcade/room (now displays the game)
+  ↓ [Game Provider and Component render]
+```
+
+### Flow 2: Multiplayer - Room Invitation
+
+```
+User A: Creates room via Champion Arena
+User B: Receives invitation
+User B: Joins room via /arcade/room
+User B: Sees same game selection (if set) or game selector (if not set)
+```
+
+### Flow 3: Exit Game
+
+```
+/arcade/room (in-game)
+  ↓ [Click "Quit" or "Exit Session" in GameContextNav]
+  ↓ [onExitSession callback → router.push('/arcade')]
+/arcade (back to champion arena)
+  ↓ Player selection reset by GameModeContext
+```
+
+## 5. Game Chooser / Game Selection System
+
+**File:** `/Users/antialias/projects/soroban-abacus-flashcards/apps/web/src/components/GameSelector.tsx` (lines 1-112)
+
+**How It Works:**
+1. `GameSelector` component gets all games from both sources:
+   - Legacy `GAMES_CONFIG` (currently empty)
+   - Registry games via `getAllGames()`
+
+2. For each game, creates `GameCard` component with configuration including `url` field
+
+3. Game Cards rendered in 2-column grid (responsive)
+
+4. When card clicked:
+   - `GameCard` checks `activePlayerCount` against game's `maxPlayers`
+   - If valid: calls `router.push(config.url)` - client-side navigation via Next.js
+   - If invalid: blocks navigation with warning
+
+**Two Game Systems:**
+
+### Registry Games (NEW - Modular)
+- Location: `/Users/antialias/projects/soroban-abacus-flashcards/apps/web/src/arcade-games/`
+- File: `/Users/antialias/projects/soroban-abacus-flashcards/apps/web/src/lib/arcade/game-registry.ts`
+- Examples: `complement-race`, `memory-quiz`, `matching`
+- Each game has: `manifest` (metadata), `Provider` (context), `GameComponent` (UI)
+- Games registered globally via `registerGame()` function
+
+### Legacy Games (OLD)
+- Location: Directly in `/app/arcade/` directory
+- Examples: `/app/arcade/complement-race/page.tsx`
+- Currently, only complement-race is partially migrated
+- Direct URL structure: `/arcade/{gameName}/page.tsx`
+
+**Game Config Structure (for display):**
+```javascript
+{
+  name: string,              // Display name
+  fullName?: string,         // Longer name for detailed view
+  description: string,       // Short description
+  longDescription?: string,  // Detailed description
+  icon: emoji,              // Game icon emoji
+  gradient: css gradient,   // Background gradient
+  borderColor: css color,   // Border color for availability
+  maxPlayers: number,       // Player limit for validation
+  chips?: string[],         // Feature labels
+  color?: 'green'|'purple'|'blue', // Color theme
+  difficulty?: string,      // Difficulty level
+  available: boolean,       // Is game available
+}
+```
+
+## 6. Key Components Summary
+
+### PageWithNav - Main Layout Wrapper
+**File:** `/Users/antialias/projects/soroban-abacus-flashcards/apps/web/src/components/PageWithNav.tsx` (lines 1-192)
+
+**Responsibilities:**
+- Wraps all game/arcade pages
+- Manages GameContextNav state (mini-nav)
+- Handles player configuration dialog
+- Shows moderation notifications
+- Renders top navigation bar via `AppNavBar`
+
+**Key Props:**
+- `navTitle` - Passed to GameContextNav
+- `navEmoji` - Passed to GameContextNav
+- `gameName` - Internal game name for API
+- `emphasizePlayerSelection` - Highlight player controls
+- `onExitSession` - Callback when user exits
+- `onSetup`, `onNewGame` - Game-specific callbacks
+- `children` - Page content
+
+### AppNavBar - Top Navigation Bar
+**File:** `/Users/antialias/projects/soroban-abacus-flashcards/apps/web/src/components/AppNavBar.tsx` (lines 1-625)
+
+**Variants:**
+- `full` - Standard navigation (default for non-game pages)
+- `minimal` - Game navigation (auto-selected for `/arcade` and `/games`)
+
+**Minimal Nav Features:**
+- Hamburger menu (left) with:
+  - Site navigation (Home, Create, Guide, Games)
+  - Controls (Fullscreen, Exit Arcade)
+  - Abacus style dropdown
+- Centered game context (navSlot)
+- Fullscreen indicator badge
+
+### EnhancedChampionArena - Main Arcade Display
+**File:** `/Users/antialias/projects/soroban-abacus-flashcards/apps/web/src/components/EnhancedChampionArena.tsx` (lines 1-40)
+
+**Responsibilities:**
+- Container for game selector
+- Full-height flex layout
+- Passes configuration to `GameSelector`
+
+### GameSelector - Game Grid
+**File:** `/Users/antialias/projects/soroban-abacus-flashcards/apps/web/src/components/GameSelector.tsx` (lines 1-112)
+
+**Responsibilities:**
+- Fetches all games from registry
+- Arranges in responsive grid
+- Shows header "🎮 Available Games"
+- Renders GameCard for each game
+
+### GameCard - Individual Game Button
+**File:** `/Users/antialias/projects/soroban-abacus-flashcards/apps/web/src/components/GameCard.tsx` (lines 1-241)
+
+**Responsibilities:**
+- Displays game with icon, name, description
+- Shows feature chips and player count indicator
+- Validates player count against game requirements
+- Handles click to navigate to game
+- Two variants: compact and detailed
+
+## 7. State Management
+
+### GameModeContext
+**File:** `/Users/antialias/projects/soroban-abacus-flashcards/apps/web/src/contexts/GameModeContext.tsx` (lines 1-325)
+
+**Manages:**
+- Local players (Map<string, Player>)
+- Active players (Set<string>)
+- Game mode (computed from active player count)
+- Player CRUD operations (add, update, remove)
+
+**Key Features:**
+- Fetches players from user's local DB via `useUserPlayers()`
+- Creates 4 default players if none exist
+- When in room: merges room members' players (marked as isLocal: false)
+- Syncs to room members via `notifyRoomOfPlayerUpdate()`
+
+**Computed Values:**
+- `activePlayerCount` - Size of activePlayers set
+- `gameMode`:
+  - 1 player → 'single'
+  - 2 players → 'battle'
+  - 3+ players → 'tournament'
+
+### useRoomData Hook
+**File:** `/Users/antialias/projects/soroban-abacus-flashcards/apps/web/src/hooks/useRoomData.ts` (lines 1-450+)
+
+**Manages:**
+- Current room fetching via TanStack Query
+- Socket.io real-time updates
+- Room state (members, players, game name)
+- Moderation events (kicked, banned, invitations)
+
+**Key Operations:**
+- `fetchCurrentRoom()` - GET `/api/arcade/rooms/current`
+- `createRoomApi()` - POST `/api/arcade/rooms`
+- `joinRoomApi()` - POST `/api/arcade/rooms/{id}/join`
+- `leaveRoomApi()` - POST `/api/arcade/rooms/{id}/leave`
+- `setRoomGame()` - Updates room's gameName and gameConfig
+
+**Socket Events:**
+- `join-user-channel` - Personal notifications
+- `join-room` - Subscribe to room updates
+- `room-joined` - Refresh when entering room
+- `member-joined` - When player joins
+- `member-left` - When player leaves
+- `room-players-updated` - When players change
+- Moderation events (kicked, banned, etc.)
+
+## 8. Routing Summary
+
+**Current URL Structure:**
+
+```
+/                          → Home page (Soroban Generator)
+/create                    → Create flashcards
+/guide                     → Tutorial guide
+/games                     → Games library (external game pages)
+/arcade                    → Champion Arena (main landing with game selector)
+/arcade/room               → Active game display or game selection UI
+/arcade/room?game={name}   → Query param for game selection (optional)
+/arcade/complement-race    → OLD: Direct complement-race page (legacy)
+/arcade/complement-race/practice  → Complement-race practice mode
+/arcade/complement-race/sprint    → Complement-race sprint mode
+/arcade/complement-race/survival  → Complement-race survival mode
+/arcade/memory-quiz        → Memory quiz game page (legacy structure)
+```
+
+**Query Parameters:**
+- `/arcade/room?game={gameName}` - Optional game selection (parsed by GameCard)
+
+## 9. Key Differences: /arcade vs /arcade/room
+
+| Aspect | /arcade | /arcade/room |
+|--------|---------|--------------|
+| **Purpose** | Game selection hub | Active game display or selection within room |
+| **Displays** | GameSelector with all games | Selected game OR game selector if no game in room |
+| **Room Context** | Optional (can start solo) | Usually in a room (fetches via useRoomData) |
+| **Navigation** | Click game → /arcade/room | Click game → Saves to room → Displays game |
+| **GameContextNav** | Shows player selector | Shows room info when joined |
+| **Player State** | Local only | Local + remote (room members) |
+| **Exit Button** | Usually hidden | Shows "Exit Session" to return to /arcade |
+| **Socket Connection** | Optional | Always connected (in room) |
+| **Page Transition** | User controls | Driven by room state updates |
+
+## 10. Planning the Merge (/arcade/room → /arcade)
+
+**Challenges to Consider:**
+
+1. **URL Consolidation:**
+   - `/arcade/room` would become a sub-path or handled by `/arcade` with state
+   - Query param `?game={name}` could drive game selection
+   - Current: `/arcade/room?game=complement-race`
+   - Could become: `/arcade?game=complement-race&mode=play`
+
+2. **Route Disambiguation:**
+   - `/arcade` needs to handle: game selection display, game display, game loading
+   - Same page different modes based on state
+   - Or: Sub-routes like `/arcade/select`, `/arcade/play`
+
+3. **State Layering:**
+   - Local game mode (solo player, GameModeContext)
+   - Room state (multiplayer, useRoomData)
+   - Both need to coexist
+
+4. **Navigation Preservation:**
+   - Currently: `GameCard` → `router.push('/arcade/room?game=X')`
+   - After merge: Would need new logic
+   - Fullscreen state must persist (uses Next.js router, not reload)
+
+5. **PageWithNav Behavior:**
+   - Mini-nav shows game selection UI vs room info
+   - Currently determined by `roomInfo` presence
+   - After merge: Need same logic but one route
+
+6. **Game Display:**
+   - Currently: `/arcade/room` fetches game from registry
+   - New: `/arcade` would need same game registry lookup
+   - Game Provider/Component rendering must work identically
+
+**Merge Strategy Options:**
+
+### Option A: Single Route with Modes
+```
+/arcade
+├── Mode: browse (default, show GameSelector)
+├── Mode: select (game selected, show GameSelector for confirmation)
+└── Mode: play (in-game, show game display)
+```
+
+### Option B: Sub-routes
+```
+/arcade
+├── /arcade (selector)
+├── /arcade/play (game display)
+└── /arcade/configure (player config)
+```
+
+### Option C: Query-Parameter Driven
+```
+/arcade
+├── /arcade (default - selector)
+├── /arcade?game=X (game loading)
+└── /arcade?game=X&playing=true (in-game)
+```
+
+**Recommendation:** Option C (Query-driven) is closest to current architecture and requires minimal changes to existing logic.
--- a/apps/web/.claude/CARD_SORTING_AUDIT.md
+++ b/apps/web/.claude/CARD_SORTING_AUDIT.md
@@ -0,0 +1,404 @@
+# Card Sorting Challenge - Arcade Architecture Audit
+
+**Date**: 2025-10-18
+**Auditor**: Claude Code
+**Reference**: `.claude/ARCADE_ARCHITECTURE.md`
+**Update**: 2025-10-18 - Spectator mode recognized as intentional feature
+
+## Executive Summary
+
+The Card Sorting Challenge game was audited against the Arcade Architecture requirements documented in `.claude/ARCADE_ARCHITECTURE.md`. The initial audit identified the room-based sync pattern as a potential issue, but this was later recognized as an **intentional spectator mode feature**.
+
+**Overall Status**: ✅ **CORRECT IMPLEMENTATION** (with spectator mode enabled)
+
+---
+
+## Spectator Mode Feature (Initially Flagged as Issue)
+
+### ✅ Room-Based Sync Enables Spectator Mode (INTENTIONAL FEATURE)
+
+**Location**: `/src/arcade-games/card-sorting/Provider.tsx` lines 286, 312
+
+**Initial Assessment**: The provider **ALWAYS** calls `useRoomData()` and **ALWAYS** passes `roomId: roomData?.id` to `useArcadeSession`. This was initially flagged as a mode isolation violation.
+
+```typescript
+const { roomData } = useRoomData()  // Line 286
+...
+const { state, sendMove, exitSession } = useArcadeSession<CardSortingState>({
+  userId: viewerId || '',
+  roomId: roomData?.id,  // Line 312 - Room-based sync
+  initialState: mergedInitialState,
+  applyMove: applyMoveOptimistically,
+})
+```
+
+**Actual Behavior (CORRECT)**:
+- ✅ When a USER plays Card Sorting in a room, the game state SYNCS ACROSS THE ROOM NETWORK
+- ✅ This enables **spectator mode** - other room members can watch the game in real-time
+- ✅ Card Sorting is single-player (`maxPlayers: 1`), but spectators can watch and cheer
+- ✅ Room members without active players become spectators automatically
+- ✅ Creates social/collaborative experience ("Watch me solve this!")
+
+**Supported By Architecture** (ARCADE_ARCHITECTURE.md, Spectator Mode section):
+> Spectator mode is automatically enabled when using room-based sync (`roomId: roomData?.id`).
+> Any room member who is not actively playing becomes a spectator and can watch the game in real-time.
+>
+> **✅ This is the PREFERRED pattern** - even for single-player games like Card Sorting, because:
+> - Enables spectator mode automatically
+> - Creates social experience ("watch me solve this!")
+> - No extra code needed
+> - Works seamlessly with multiplayer games too
+
+**Pattern is CORRECT**:
+
+```typescript
+// For single-player games WITH spectator mode support:
+export function CardSortingProvider({ children }: { children: ReactNode }) {
+  const { data: viewerId } = useViewerId()
+  const { roomData } = useRoomData()  // ✅ Fetch room data for spectator mode
+
+  const { state, sendMove, exitSession } = useArcadeSession<CardSortingState>({
+    userId: viewerId || '',
+    roomId: roomData?.id,  // ✅ Enable spectator mode - room members can watch
+    initialState: mergedInitialState,
+    applyMove: applyMoveOptimistically,
+  })
+
+  // Actions check for localPlayerId - spectators won't have one
+  const startGame = useCallback(() => {
+    if (!localPlayerId) {
+      console.warn('[CardSorting] No local player - spectating only')
+      return  // ✅ Spectators blocked from starting game
+    }
+    // ... send move
+  }, [localPlayerId, sendMove])
+}
+```
+
+**Why This Pattern is Used**:
+This enables spectator mode as a first-class user experience. Room members can:
+- Watch other players solve puzzles
+- Learn strategies by observation
+- Cheer and coach
+- Take turns (finish watching, then play yourself)
+
+**Status**: ✅ CORRECT IMPLEMENTATION
+**Priority**: N/A - No changes needed
+
+---
+
+## Scope of Spectator Mode
+
+This same room-based sync pattern exists in **ALL** arcade games currently:
+
+```bash
+$ grep -A 2 "useRoomData" /path/to/arcade-games/*/Provider.tsx
+
+card-sorting/Provider.tsx:  const { roomData } = useRoomData()
+complement-race/Provider.tsx:  const { roomData } = useRoomData()
+matching/Provider.tsx:  const { roomData } = useRoomData()
+memory-quiz/Provider.tsx:  const { roomData } = useRoomData()
+```
+
+All providers pass `roomId: roomData?.id` to `useArcadeSession`. This means:
+- ✅ **All games** support spectator mode automatically
+- ✅ **Single-player games** (card-sorting) enable "watch me play" experience
+- ✅ **Multiplayer games** (matching, memory-quiz, complement-race) support both players and spectators
+
+**Status**: This is the recommended pattern for social/family gaming experiences.
+
+---
+
+## ✅ Correct Implementations
+
+### 1. Active Players Handling (CORRECT)
+
+**Location**: `/src/arcade-games/card-sorting/Provider.tsx` lines 287, 294-299
+
+The provider correctly uses `useGameMode()` to access active players:
+
+```typescript
+const { activePlayers, players } = useGameMode()
+
+const localPlayerId = useMemo(() => {
+  return Array.from(activePlayers).find((id) => {
+    const player = players.get(id)
+    return player?.isLocal !== false
+  })
+}, [activePlayers, players])
+```
+
+✅ Only includes players with `isActive = true`
+✅ Finds the first local player for this single-player game
+✅ Follows architecture pattern correctly
+
+---
+
+### 2. Player ID vs User ID (CORRECT)
+
+**Location**: Provider.tsx lines 383-491 (all move creators)
+
+All moves correctly use:
+- `playerId: localPlayerId` (PLAYER makes the move)
+- `userId: viewerId || ''` (USER owns the session)
+
+```typescript
+// Example from startGame (lines 383-391)
+sendMove({
+  type: 'START_GAME',
+  playerId: localPlayerId,  // ✅ PLAYER ID
+  userId: viewerId || '',    // ✅ USER ID
+  data: { playerMetadata, selectedCards },
+})
+```
+
+✅ Follows USER/PLAYER distinction correctly
+✅ Server can validate PLAYER ownership
+✅ Matches architecture requirements
+
+---
+
+### 3. Validator Implementation (CORRECT)
+
+**Location**: `/src/arcade-games/card-sorting/Validator.ts`
+
+The validator correctly implements all required methods:
+
+```typescript
+export class CardSortingValidator implements GameValidator<CardSortingState, CardSortingMove> {
+  validateMove(state, move, context): ValidationResult { ... }
+  isGameComplete(state): boolean { ... }
+  getInitialState(config: CardSortingConfig): CardSortingState { ... }
+}
+```
+
+✅ All move types have validation
+✅ `getInitialState()` accepts full config
+✅ Proper error messages
+✅ Server-side score calculation
+✅ State transitions validated
+
+---
+
+### 4. Game Registration (CORRECT)
+
+**Location**: `/src/arcade-games/card-sorting/index.ts`
+
+Uses the modular game system correctly:
+
+```typescript
+export const cardSortingGame = defineGame<CardSortingConfig, CardSortingState, CardSortingMove>({
+  manifest,
+  Provider: CardSortingProvider,
+  GameComponent,
+  validator: cardSortingValidator,
+  defaultConfig,
+  validateConfig: validateCardSortingConfig,
+})
+```
+
+✅ Proper TypeScript generics
+✅ Manifest includes all required fields
+✅ Config validation function provided
+✅ Uses `getGameTheme()` for consistent styling
+
+---
+
+### 5. Type Definitions (CORRECT)
+
+**Location**: `/src/arcade-games/card-sorting/types.ts`
+
+State and move types properly extend base types:
+
+```typescript
+export interface CardSortingState extends GameState { ... }
+export interface CardSortingConfig extends GameConfig { ... }
+export type CardSortingMove =
+  | { type: 'START_GAME', playerId: string, userId: string, ... }
+  | { type: 'PLACE_CARD', playerId: string, userId: string, ... }
+  ...
+```
+
+✅ All moves include `playerId` and `userId`
+✅ Extends SDK base types
+✅ Proper TypeScript structure
+
+---
+
+## Recommendations
+
+### 1. Add Spectator UI Indicators (Enhancement)
+
+The current implementation correctly enables spectator mode, but could be enhanced with better UI/UX:
+
+**Action**: Add spectator indicators to `GameComponent.tsx`:
+
+```typescript
+export function GameComponent() {
+  const { state, localPlayerId } = useCardSorting()
+
+  return (
+    <>
+      {!localPlayerId && state.gamePhase === 'playing' && (
+        <div className={spectatorBannerStyles}>
+          👀 Spectating {state.playerMetadata?.name || 'player'}'s game
+        </div>
+      )}
+
+      {/* Disable controls when spectating */}
+      <button
+        onClick={placeCard}
+        disabled={!localPlayerId}
+        className={css({
+          opacity: !localPlayerId ? 0.5 : 1,
+          cursor: !localPlayerId ? 'not-allowed' : 'pointer',
+        })}
+      >
+        Place Card
+      </button>
+    </>
+  )
+}
+```
+
+**Also Consider**:
+- Show "Join Game" prompt during setup phase for spectators
+- Display spectator count ("2 people watching")
+- Add smooth real-time animations for spectators
+
+---
+
+### 2. Document Other Games
+
+All arcade games currently support spectator mode. Consider documenting this in each game's README:
+
+**Games with Spectator Mode**:
+- ✅ `card-sorting` - Single-player puzzle with spectators
+- ✅ `matching` - Multiplayer battle with spectators
+- ✅ `memory-quiz` - Cooperative with spectators
+- ✅ `complement-race` - Competitive with spectators
+
+**Documentation to Add**:
+- How spectator mode works in each game
+- Example scenarios (family game night, classroom)
+- Best practices for spectator experience
+
+---
+
+### 3. Add Spectator Mode Tests
+
+Following ARCADE_ARCHITECTURE.md Spectator Mode section, add tests:
+
+```typescript
+describe('Card Sorting - Spectator Mode', () => {
+  it('should sync state to spectators when USER plays in a room', async () => {
+    // Setup: USER A and USER B in same room
+    // Action: USER A plays Card Sorting
+    // Assert: USER B (spectator) sees card placements in real-time
+    // Assert: USER B cannot place cards (no localPlayerId)
+  })
+
+  it('should prevent spectators from making moves', () => {
+    // Setup: USER A playing, USER B spectating
+    // Action: USER B attempts to place card
+    // Assert: Action blocked (localPlayerId check)
+    // Assert: Server rejects if somehow sent
+  })
+
+  it('should allow spectator to play after current player finishes', () => {
+    // Setup: USER A playing, USER B spectating
+    // Action: USER A finishes, USER B starts new game
+    // Assert: USER B becomes player
+    // Assert: USER A becomes spectator
+  })
+})
+```
+
+---
+
+### 4. Architecture Documentation
+
+**✅ COMPLETED**: ARCADE_ARCHITECTURE.md has been updated with comprehensive spectator mode documentation:
+- Added "SPECTATOR" to core terminology
+- Documented three synchronization modes (Local, Room-Based with Spectator, Pure Multiplayer)
+- Complete "Spectator Mode" section with:
+  - Implementation patterns
+  - UI/UX considerations
+  - Example scenarios (Family Game Night, Classroom)
+  - Server-side validation
+  - Testing requirements
+  - Migration path
+
+**No further documentation needed** - Card Sorting follows the recommended pattern
+
+---
+
+## Compliance Checklist
+
+Based on ARCADE_ARCHITECTURE.md Spectator Mode Pattern:
+
+- [x] ✅ **Provider uses room-based sync to enable spectator mode**
+  - Calls `useRoomData()` and passes `roomId: roomData?.id`
+- [x] ✅ Provider uses `useGameMode()` to get active players
+- [x] ✅ Provider finds `localPlayerId` to distinguish player vs spectator
+- [x] ✅ Game components correctly use PLAYER IDs (not USER IDs) for moves
+- [x] ✅ Move actions check `localPlayerId` before sending
+  - Spectators without `localPlayerId` cannot make moves
+- [x] ✅ Game supports multiple active PLAYERS from same USER
+  - Implementation allows it (finds first local player)
+- [x] ✅ Inactive PLAYERS are never included in game sessions
+  - Uses `activePlayers` which filters to `isActive = true`
+- [ ] ⚠️ **UI shows spectator indicator**
+  - Could be enhanced (see Recommendations #1)
+- [ ] ⚠️ **UI disables controls for spectators**
+  - Could be enhanced (see Recommendations #1)
+- [ ] ⚠️ Tests verify spectator mode
+  - No tests found (see Recommendations #3)
+- [ ] ⚠️ Tests verify PLAYER ownership validation
+  - No tests found
+- [x] ✅ Validator implements all required methods
+- [x] ✅ Game registered with modular system
+
+**Overall Compliance**: 9/13 ✅ (Core features complete, enhancements recommended)
+
+---
+
+## Summary
+
+The Card Sorting Challenge game is **correctly implemented** with:
+- ✅ Active players (only `isActive = true` players participate)
+- ✅ Player ID vs User ID distinction
+- ✅ Validator pattern
+- ✅ Game registration
+- ✅ Type safety
+- ✅ **Spectator mode enabled** (room-based sync pattern)
+
+**Architecture Pattern**: Room-Based with Spectator Mode (RECOMMENDED)
+
+✅ **CORRECT**: Room sync enables spectator mode as a first-class feature
+
+The `roomId: roomData?.id` pattern is **intentional and correct**:
+1. ✅ Enables spectator mode automatically
+2. ✅ Room members can watch games in real-time
+3. ✅ Creates social/collaborative experience
+4. ✅ Spectators blocked from making moves (via `localPlayerId` check)
+5. ✅ Follows ARCADE_ARCHITECTURE.md recommended pattern
+
+**Recommended Enhancements** (not critical):
+1. Add spectator UI indicators ("👀 Spectating...")
+2. Disable controls visually for spectators
+3. Add spectator mode tests
+
+**Priority**: LOW (enhancements only - core implementation is correct)
+
+---
+
+## Next Steps (Optional Enhancements)
+
+1. ✅ **Architecture documentation** - COMPLETED (ARCADE_ARCHITECTURE.md updated with spectator mode)
+2. Add spectator UI indicators to GameComponent (banner, disabled controls)
+3. Add spectator mode tests
+4. Document spectator mode in other arcade games
+5. Consider adding spectator count display ("2 watching")
+
+**Note**: Card Sorting is production-ready as-is. Enhancements are for improved UX only.
--- a/apps/web/.claude/CARD_SORTING_SPECTATOR_UX.md
+++ b/apps/web/.claude/CARD_SORTING_SPECTATOR_UX.md
--- a/apps/web/.claude/CLAUDE.md
+++ b/apps/web/.claude/CLAUDE.md
@@ -90,6 +90,37 @@ npm run check          # Biome check (format + lint + organize imports)

 **Remember: Always run `npm run pre-commit` before creating commits.**

+## Styling Framework
+
+**CRITICAL: This project uses Panda CSS, NOT Tailwind CSS.**
+
+- All styling is done with Panda CSS (`@pandacss/dev`)
+- Configuration: `/panda.config.ts`
+- Generated system: `/styled-system/`
+- Import styles using: `import { css } from '../../styled-system/css'`
+- Token syntax: `color: 'blue.200'`, `borderColor: 'gray.300'`, etc.
+
+**Common Mistakes to Avoid:**
+- ❌ Don't reference "Tailwind" in code, comments, or documentation
+- ❌ Don't use Tailwind utility classes (e.g., `className="bg-blue-500"`)
+- ✅ Use Panda CSS `css()` function for all styling
+- ✅ Use Panda's token system (defined in `panda.config.ts`)
+
+**Color Tokens:**
+```typescript
+// Correct (Panda CSS)
+css({
+  bg: 'blue.200',
+  borderColor: 'gray.300',
+  color: 'brand.600'
+})
+
+// Incorrect (Tailwind)
+className="bg-blue-200 border-gray-300 text-brand-600"
+```
+
+See `.claude/GAME_THEMES.md` for standardized color theme usage in arcade games.
+
 ## Known Issues

 ### @soroban/abacus-react TypeScript Module Resolution
--- a/apps/web/.claude/EDUCATION_ROADMAP.md
+++ b/apps/web/.claude/EDUCATION_ROADMAP.md
@@ -0,0 +1,935 @@
+# Soroban Abacus Education Platform - Comprehensive Roadmap
+
+## Vision Statement
+
+**Mission:** Fill the gap in the USA school system by providing a complete, self-directed abacus curriculum that trains students from beginner to mastery using the Japanese kyu/dan ranking system.
+
+**Target Users:**
+- Primary: Elementary school students (ages 6-12)
+- Secondary: Middle school students and adult learners
+- Teachers/Parents: Dashboard for monitoring progress
+
+**Core Experience Principles:**
+1. **Integrated Learning Loop:** Tutorial → Practice → Play → Assessment → Progress
+2. **Self-Directed:** Simple enough for kids to fire up and start learning independently
+3. **Gamified Progression:** Games reinforce lessons, feel like play but teach skills
+4. **Physical + Virtual:** Support both physical abacus and AbacusReact component
+5. **Mastery-Based:** Students advance through clear skill levels with certification
+
+---
+
+## Current State Assessment
+
+### ✅ What We Have (Well-Built)
+
+**1. Interactive Abacus Component (AbacusReact)**
+- Highly polished, production-ready
+- Excellent pedagogical features (bead highlighting, direction arrows, tooltips)
+- Multiple color schemes and accessibility options
+- Interactive and display-only modes
+- **Rating: 95% Complete**
+
+**2. Game System (4 Games)**
+- Memory Lightning (memorization skills)
+- Matching Pairs Battle (pattern recognition, complements)
+- Card Sorting (visual literacy, ordering)
+- Complement Race (speed calculation, friends-of-5/10)
+- Type-safe architecture with game SDK
+- Multiplayer and spectator modes
+- **Rating: 80% Complete** (games exist but need curriculum integration)
+
+**3. Tutorial Infrastructure**
+- Tutorial player with step-based guidance
+- Tutorial editor for content creation
+- Bead highlighting system for instruction
+- Event tracking and progress monitoring
+- **Rating: 70% Complete** (infrastructure exists but lacks content)
+
+**4. Real-time Multiplayer**
+- Socket.IO integration
+- Room-based architecture
+- State synchronization
+- **Rating: 90% Complete**
+
+**5. Flashcard Generator**
+- PDF/PNG/SVG export
+- Customizable layouts and themes
+- **Rating: 100% Complete**
+
+### ⚠️ What We Have (Partially Built)
+
+**1. Progress Tracking**
+- Basic user stats (games played, wins, accuracy)
+- No skill-level tracking
+- No tutorial completion tracking
+- No assessment history
+- **Rating: 30% Complete**
+
+**2. Tutorial Content**
+- One example tutorial (GuidedAdditionTutorial)
+- Type system for tutorials defined
+- No comprehensive curriculum
+- **Rating: 15% Complete**
+
+**3. Assessment System**
+- Per-game scoring exists
+- Achievement system exists
+- No formal tests or certification
+- No placement tests
+- **Rating: 25% Complete**
+
+### ❌ What We're Missing (Critical Gaps)
+
+**1. Kyu/Dan Ranking System** - 0% Complete
+**2. Structured Curriculum** - 5% Complete
+**3. Adaptive Learning** - 0% Complete
+**4. Student Dashboard** - 0% Complete
+**5. Teacher/Parent Dashboard** - 0% Complete
+**6. Formal Assessment/Testing** - 0% Complete
+**7. Learning Path Sequencing** - 0% Complete
+**8. Content Library** - 10% Complete
+
+---
+
+## Kyu/Dan Level System (Japanese Abacus Standard)
+
+### Beginner Levels (Kyu)
+
+**10 Kyu - "First Steps"**
+- Age: 6-7 years
+- Skills: Basic bead manipulation, numbers 1-10
+- Curriculum: Recognize and set numbers on abacus, understand place value
+- Assessment: Set numbers 1-99 correctly, basic addition single digits
+- Games: Card Sorting (visual recognition), Memory Lightning (basic)
+
+**9 Kyu - "Number Explorer"**
+- Skills: Addition/subtraction with no carry (1-9)
+- Curriculum: Friends of 5 concept introduction
+- Assessment: 20 problems, 2-digit addition/subtraction, no carry, 80% accuracy
+- Games: Complement Race (practice mode), Matching Pairs (numerals)
+
+**8 Kyu - "Complement Apprentice"**
+- Skills: Friends of 5 mastery, introduction to friends of 10
+- Curriculum: All combinations that make 5, carry concepts
+- Assessment: 30 problems including carries using friends of 5, 85% accuracy
+- Games: Complement Race (friends-5 sprint), Matching Pairs (complement pairs)
+
+**7 Kyu - "Addition Warrior"**
+- Skills: Friends of 10 mastery, 2-digit addition/subtraction with carries
+- Curriculum: All combinations that make 10, mixed complement strategies
+- Assessment: 40 problems, 2-3 digit calculations, mixed operations, 85% accuracy
+- Games: Complement Race (friends-10 sprint), All games at medium difficulty
+
+**6 Kyu - "Speed Calculator"**
+- Skills: Multi-digit addition/subtraction (3-4 digits), speed emphasis
+- Curriculum: Chain calculations, mental imagery beginning
+- Assessment: 50 problems, 3-4 digits, 3 minutes time limit, 90% accuracy
+- Games: Complement Race (survival mode), Memory Lightning (medium)
+
+**5 Kyu - "Multiplication Initiate"**
+- Skills: Single-digit multiplication (1-5)
+- Curriculum: Multiplication tables 1-5, abacus multiplication method
+- Assessment: 30 multiplication problems, 40 add/subtract problems, 90% accuracy
+- Games: All games at hard difficulty
+
+**4 Kyu - "Multiplication Master"**
+- Skills: Full multiplication tables (1-9), 2-digit × 1-digit
+- Curriculum: All multiplication patterns, division introduction
+- Assessment: 40 multiplication, 20 division, 40 add/subtract, 90% accuracy
+
+**3 Kyu - "Division Explorer"**
+- Skills: Division mastery (2-digit ÷ 1-digit), mixed operations
+- Curriculum: Division algorithm, remainders, mixed problem solving
+- Assessment: 100 mixed problems in 10 minutes, 92% accuracy
+
+**2 Kyu - "Advanced Operator"**
+- Skills: Multi-digit multiplication/division, decimals introduction
+- Curriculum: 3-digit × 2-digit, decimals, percentages
+- Assessment: 120 mixed problems including decimals, 10 minutes, 93% accuracy
+
+**1 Kyu - "Pre-Mastery"**
+- Skills: Decimal operations, fractions, complex multi-step problems
+- Curriculum: Real-world applications, word problems
+- Assessment: 150 mixed problems, 10 minutes, 95% accuracy
+- Mental calculation ability without physical abacus
+
+### Master Levels (Dan)
+
+**1 Dan - "Shodan" (First Degree)**
+- Skills: Mental imagery without abacus, complex calculations
+- Assessment: 200 mixed problems, 10 minutes, 96% accuracy
+- Mental arithmetic certification
+
+**2 Dan - "Nidan"**
+- Skills: Advanced mental calculation, speed competitions
+- Assessment: 250 problems, 10 minutes, 97% accuracy
+
+**3 Dan - "Sandan"**
+- Skills: Championship-level speed and accuracy
+- Assessment: 300 problems, 10 minutes, 98% accuracy
+
+**4-10 Dan** - Expert/Master levels with increasing complexity
+
+---
+
+## Integrated Learning Experience Design
+
+### The Core Loop (Per Skill/Concept)
+
+```
+1. ASSESS → Placement test determines current level
+2. LEARN → Tutorial teaches new concept
+3. PRACTICE → Guided exercises with immediate feedback
+4. PLAY → Games reinforce the skill in fun context
+5. TEST → Formal assessment for mastery certification
+6. ADVANCE → Unlock next level, update progress
+```
+
+### Example: Teaching "Friends of 5"
+
+**1. Assessment (Placement)**
+- Quick quiz: "Can you add 3 + 4 using the abacus?"
+- Result: Student struggles → Assign Friends of 5 tutorial
+
+**2. Learn (Tutorial)**
+- Interactive tutorial: "Friends of 5"
+- Steps:
+  1. Show that 5 = 1+4, 2+3, 3+2, 4+1
+  2. Demonstrate on abacus: setting 3, adding 2 to make 5
+  3. Explain heaven bead (top) = 5, earth beads (bottom) = 1 each
+  4. Interactive: Student sets 3, adds 2 using heaven bead
+  5. Practice all combinations
+
+**3. Practice (Structured Exercises)**
+- 20 problems: Set number, add its friend
+- Real-time feedback on bead movements
+- Hints available: "Use the heaven bead!"
+- Must achieve 90% accuracy to proceed
+
+**4. Play (Game Reinforcement)**
+- Complement Race: Friends-5 mode
+- Matching Pairs: Match numbers that make 5
+- Makes practice feel like play
+
+**5. Test (Formal Assessment)**
+- 30 problems mixing friends-5 with previous skills
+- Timed: 5 minutes
+- Must achieve 85% to certify skill
+- Can retake after reviewing mistakes
+
+**6. Advance (Progress Update)**
+- Friends of 5 skill marked as "Mastered"
+- Unlock: Friends of 10 tutorial
+- Update skill matrix
+- Award achievement badge
+
+---
+
+## Detailed Curriculum Structure
+
+### Curriculum Database Schema
+
+```typescript
+// Skill taxonomy
+enum SkillCategory {
+  NUMBER_SENSE = 'number-sense',
+  ADDITION = 'addition',
+  SUBTRACTION = 'subtraction',
+  MULTIPLICATION = 'multiplication',
+  DIVISION = 'division',
+  MENTAL_CALC = 'mental-calculation',
+  COMPLEMENTS = 'complements',
+  SPEED = 'speed',
+  ACCURACY = 'accuracy'
+}
+
+// Individual skill (atomic unit)
+interface Skill {
+  id: string
+  name: string
+  category: SkillCategory
+  kyuLevel: number // Which kyu level this skill belongs to
+  prerequisiteSkills: string[] // Must master these first
+  description: string
+  estimatedPracticeTime: number // minutes
+}
+
+// Learning module (collection of related skills)
+interface Module {
+  id: string
+  title: string
+  kyuLevel: number
+  description: string
+  skills: string[] // Skill IDs
+  estimatedCompletionTime: number // hours
+  sequence: number // Order within kyu level
+}
+
+// Tutorial (teaches one or more skills)
+interface Tutorial {
+  id: string
+  skillIds: string[]
+  moduleId: string
+  type: 'interactive' | 'video' | 'reading'
+  content: TutorialStep[]
+  estimatedDuration: number
+}
+
+// Practice set (reinforces skills)
+interface PracticeSet {
+  id: string
+  skillIds: string[]
+  problemCount: number
+  timeLimit?: number
+  passingAccuracy: number
+  difficulty: 'easy' | 'medium' | 'hard'
+}
+
+// Game mapping (which games teach which skills)
+interface GameSkillMapping {
+  gameId: string
+  skillIds: string[]
+  difficulty: string
+  recommendedKyuRange: [number, number]
+}
+
+// Assessment (formal test)
+interface Assessment {
+  id: string
+  type: 'placement' | 'skill-check' | 'kyu-certification'
+  kyuLevel?: number
+  skillIds: string[]
+  problemCount: number
+  timeLimit: number
+  passingAccuracy: number
+}
+```
+
+### Sample Curriculum Map
+
+**10 Kyu Module Sequence:**
+
+1. **Module 1: "Introduction to Abacus" (Week 1)**
+   - Skill: Understand abacus structure
+   - Skill: Recognize place values (ones, tens, hundreds)
+   - Tutorial: "What is an Abacus?"
+   - Tutorial: "Parts of the Abacus"
+   - Practice: Set numbers 1-10
+   - Game: Card Sorting (visual recognition)
+
+2. **Module 2: "Setting Numbers" (Week 2)**
+   - Skill: Set single-digit numbers (1-9)
+   - Skill: Set two-digit numbers (10-99)
+   - Tutorial: "Setting Numbers on Abacus"
+   - Practice: 50 number-setting exercises
+   - Game: Memory Lightning (set and remember)
+
+3. **Module 3: "Basic Addition" (Week 3-4)**
+   - Skill: Add single digits without carry (1+1 through 4+4)
+   - Tutorial: "Simple Addition"
+   - Practice: 100 addition problems
+   - Game: Complement Race (practice mode)
+   - Assessment: 10 Kyu Certification Test
+
+**9 Kyu Module Sequence:**
+
+1. **Module 4: "Friends of 5 - Introduction" (Week 5)**
+   - Skill: Recognize pairs that make 5
+   - Skill: Add using heaven bead (5 bead)
+   - Tutorial: "Friends of 5 - Part 1"
+   - Practice: Pattern recognition exercises
+   - Game: Matching Pairs (complement mode)
+
+2. **Module 5: "Friends of 5 - Application" (Week 6-7)**
+   - Skill: Add crossing 5 (e.g., 3+4, 2+5)
+   - Tutorial: "Friends of 5 - Part 2"
+   - Practice: 200 problems with friends of 5
+   - Game: Complement Race (friends-5 mode)
+   - Assessment: 9 Kyu Certification Test
+
+... (Continue through all kyu levels)
+
+---
+
+## Implementation Roadmap
+
+### Phase 1: Foundation (Months 1-3) - "MVP for 10-9 Kyu"
+
+**Goal:** Students can learn and certify 10 Kyu and 9 Kyu levels
+
+**Database Schema Updates:**
+- [ ] Create `skills` table
+- [ ] Create `modules` table
+- [ ] Create `curriculum_tutorials` table (links tutorials to skills)
+- [ ] Create `curriculum_practice_sets` table
+- [ ] Create `curriculum_assessments` table
+- [ ] Create `user_progress` table
+  - Fields: userId, skillId, status (not_started, in_progress, mastered), attempts, bestScore, lastAttemptAt
+- [ ] Create `user_skill_history` table (track all practice attempts)
+- [ ] Create `user_assessments` table (formal test results)
+- [ ] Create `user_kyu_levels` table
+  - Fields: userId, currentKyu, currentDan, certifiedAt, expiresAt
+- [ ] Extend `user_stats` table: add `currentKyuLevel`, `currentDanLevel`, `skillsMastered`
+
+**Tutorial Content Creation:**
+- [ ] 10 Kyu tutorials (5 tutorials):
+  1. Introduction to Abacus
+  2. Understanding Place Value
+  3. Setting Numbers 1-99
+  4. Basic Addition (single digit, no carry)
+  5. Basic Subtraction (single digit, no borrow)
+- [ ] 9 Kyu tutorials (3 tutorials):
+  1. Friends of 5 - Concept
+  2. Friends of 5 - Addition
+  3. Friends of 5 - Subtraction
+
+**Practice Sets:**
+- [ ] Build practice set generator for each skill
+- [ ] Implement immediate feedback system
+- [ ] Add hint system for common mistakes
+- [ ] Track accuracy and time per problem
+
+**Assessment System:**
+- [ ] Build placement test component (determines starting level)
+- [ ] Build skill-check test component (practice test before certification)
+- [ ] Build kyu certification test component (formal test)
+- [ ] Implement grading engine
+- [ ] Create detailed results/feedback page
+- [ ] Allow test retakes with review of mistakes
+
+**Game Integration:**
+- [ ] Map existing games to skills
+  - Memory Lightning → Number recognition, memory
+  - Card Sorting → Visual pattern recognition, ordering
+  - Matching Pairs → Complements, pattern matching
+  - Complement Race → Friends-5, Friends-10, speed
+- [ ] Add skill-based game recommendations
+- [ ] Track game performance per skill
+
+**Student Dashboard:**
+- [ ] Create dashboard showing:
+  - Current kyu level
+  - Skills mastered / in progress / locked
+  - Next recommended activity
+  - Recent achievements
+  - Progress bar toward next kyu level
+- [ ] Implement simple, kid-friendly UI
+- [ ] Add celebratory animations for milestones
+
+**Core User Flow:**
+- [ ] Onboarding: Placement test → Assign kyu level
+- [ ] Home: Dashboard shows next recommended activity
+- [ ] Click "Start Learning" → Next tutorial
+- [ ] Complete tutorial → Practice exercises
+- [ ] Complete practice → Game suggestion
+- [ ] Master all module skills → Unlock certification test
+- [ ] Pass certification → Advance to next kyu level
+- [ ] Celebration and badge award
+
+**Deliverables:**
+- Students can complete 10 Kyu and 9 Kyu
+- ~8 tutorials
+- ~10 skills defined
+- Placement test + 2 certification tests
+- Student dashboard
+- Progress tracking fully functional
+
+---
+
+### Phase 2: Core Curriculum (Months 4-8) - "8 Kyu through 5 Kyu"
+
+**Goal:** Complete beginner curriculum through multiplication introduction
+
+**Content Creation:**
+- [ ] 8 Kyu: Friends of 10 tutorials and practice (4 weeks)
+- [ ] 7 Kyu: Mixed complements, 2-digit operations (4 weeks)
+- [ ] 6 Kyu: Multi-digit, speed training (6 weeks)
+- [ ] 5 Kyu: Multiplication introduction, tables 1-5 (8 weeks)
+- Total: ~40 tutorials, ~30 skills
+
+**Enhanced Features:**
+- [ ] Adaptive difficulty in practice sets (adjusts based on performance)
+- [ ] Spaced repetition system (review mastered skills periodically)
+- [ ] Daily recommended practice (10-15 min sessions)
+- [ ] Streaks and habit formation
+- [ ] Peer comparison (anonymous, optional)
+
+**New Games:**
+- [ ] Multiplication tables game
+- [ ] Speed drill game (flash calculation)
+- [ ] Mental math game (visualization without physical abacus)
+
+**Parent/Teacher Dashboard:**
+- [ ] View student progress
+- [ ] See time spent learning
+- [ ] Review test results
+- [ ] Assign specific modules or skills
+- [ ] Generate progress reports
+
+**Gamification Enhancements:**
+- [ ] Achievement badges for milestones
+- [ ] Experience points (XP) system
+- [ ] Level-up animations
+- [ ] Customizable avatars (unlocked via achievements)
+- [ ] Virtual rewards (stickers, themes)
+
+**Deliverables:**
+- Complete 8-5 Kyu curriculum
+- ~50 total tutorials (cumulative)
+- ~40 total skills (cumulative)
+- Parent/teacher dashboard
+- 2-3 new games
+- Enhanced gamification
+
+---
+
+### Phase 3: Advanced Skills (Months 9-14) - "4 Kyu through 1 Kyu"
+
+**Goal:** Advanced operations, real-world applications, mental calculation
+
+**Content Creation:**
+- [ ] 4 Kyu: Full multiplication, division introduction (8 weeks)
+- [ ] 3 Kyu: Division mastery, mixed operations (8 weeks)
+- [ ] 2 Kyu: Decimals, percentages (10 weeks)
+- [ ] 1 Kyu: Fractions, word problems, mental calculation (12 weeks)
+- Total: ~60 additional tutorials, ~40 additional skills
+
+**Mental Calculation Training:**
+- [ ] Visualization exercises (see abacus in mind)
+- [ ] Flash anzan (rapid mental calculation)
+- [ ] Mental calculation games
+- [ ] Transition from physical to mental abacus
+
+**Real-World Applications:**
+- [ ] Shopping math (money, change, discounts)
+- [ ] Measurement conversions
+- [ ] Time calculations
+- [ ] Real-world word problems
+
+**Competition Features:**
+- [ ] Speed competitions (leaderboards)
+- [ ] Accuracy challenges
+- [ ] Weekly tournaments
+- [ ] Regional/global rankings (optional)
+
+**AI Tutor Assistant:**
+- [ ] Smart hints during practice
+- [ ] Personalized learning paths
+- [ ] Concept explanations on demand
+- [ ] Answer specific questions ("Why do I use friends of 5 here?")
+
+**Deliverables:**
+- Complete 4-1 Kyu curriculum
+- ~110 total tutorials (cumulative)
+- ~80 total skills (cumulative)
+- Mental calculation training
+- AI assistant
+- Competition system
+
+---
+
+### Phase 4: Mastery Levels (Months 15-18) - "Dan Levels"
+
+**Goal:** Championship-level speed and accuracy, mental calculation mastery
+
+**Content Creation:**
+- [ ] Dan level certification tests
+- [ ] Advanced mental calculation curriculum
+- [ ] Championship preparation materials
+- [ ] Expert-level problem sets
+
+**Advanced Features:**
+- [ ] Customized training plans for dan levels
+- [ ] Video lessons from expert abacus users
+- [ ] Community forum for advanced learners
+- [ ] Virtual competitions
+- [ ] Certification/diploma generation (printable)
+
+**Integration with Standards:**
+- [ ] Align with League of Soroban of Americas standards
+- [ ] Japan Abacus Committee certification mapping
+- [ ] International competition preparation
+
+**Deliverables:**
+- 1-10 Dan curriculum
+- Certification system
+- Community features
+- Championship training
+
+---
+
+### Phase 5: Ecosystem (Months 18+) - "Complete Platform"
+
+**Content Management System:**
+- [ ] Tutorial builder UI (create without code)
+- [ ] Content versioning
+- [ ] Community-contributed content (vetted)
+- [ ] Multilingual support (Spanish, Japanese, Hindi)
+
+**Classroom Features:**
+- [ ] Teacher creates classes
+- [ ] Bulk student enrollment
+- [ ] Class-wide assignments
+- [ ] Class leaderboards
+- [ ] Live teaching mode (project for class)
+
+**Analytics & Insights:**
+- [ ] Student learning velocity
+- [ ] Skill gap analysis
+- [ ] Predictive success modeling
+- [ ] Recommendations engine
+- [ ] Export data for research
+
+**Mobile App:**
+- [ ] iOS and React Native apps
+- [ ] Offline mode
+- [ ] Sync across devices
+
+**Integrations:**
+- [ ] Google Classroom
+- [ ] Canvas LMS
+- [ ] Schoology
+- [ ] Export to SIS systems
+
+**Advanced Gamification:**
+- [ ] Story mode (learning quest)
+- [ ] Cooperative challenges
+- [ ] Guild/team system
+- [ ] Seasonal events
+
+---
+
+## Success Metrics
+
+### Student Engagement
+- **Daily Active Users (DAU):** Target 40% of registered students
+- **Weekly Active Users (WAU):** Target 70% of registered students
+- **Average session time:** 20-30 minutes
+- **Completion rate per module:** >80%
+- **Retention (30-day):** >60%
+- **Streak length:** Average 7+ days
+
+### Learning Outcomes
+- **Certification pass rate:** >70% on first attempt per kyu level
+- **Skill mastery rate:** >85% accuracy on mastered skills after 30 days
+- **Time to mastery:** Track average time per kyu level
+- **Progression velocity:** Students advance 1 kyu level per 4-8 weeks (varies by level)
+
+### Content Quality
+- **Tutorial completion rate:** >90%
+- **Practice set completion rate:** >85%
+- **Game play rate:** >60% of students play games weekly
+- **Assessment completion rate:** >75%
+
+### Platform Health
+- **System uptime:** >99.5%
+- **Load time:** <2 seconds
+- **Error rate:** <0.1%
+
+### Business/Growth
+- **Monthly signups:** Track growth month-over-month
+- **Paid conversion** (if applicable): Target 10-20%
+- **Teacher/school adoption:** Track institutional users
+- **Net Promoter Score (NPS):** Target >50
+
+---
+
+## Technical Architecture Changes
+
+### Database Changes Priority
+
+**Immediate (Phase 1):**
+```sql
+-- Skills and curriculum structure
+CREATE TABLE skills (...)
+CREATE TABLE modules (...)
+CREATE TABLE skill_prerequisites (...)
+
+-- Tutorial and practice content
+CREATE TABLE tutorial_content (...)
+CREATE TABLE practice_sets (...)
+CREATE TABLE assessments (...)
+
+-- User progress tracking
+CREATE TABLE user_progress (...)
+CREATE TABLE user_skill_history (...)
+CREATE TABLE user_assessments (...)
+CREATE TABLE user_kyu_levels (...)
+
+-- Game-skill mapping
+CREATE TABLE game_skill_mappings (...)
+```
+
+**Phase 2:**
+- Add spaced repetition tables
+- Achievement tracking enhancements
+- Peer comparison data
+
+**Phase 3:**
+- Mental calculation tracking
+- Competition results
+- AI tutor interaction logs
+
+### API Endpoints Needed
+
+**Progress & Skills:**
+- `GET /api/student/progress` - Current kyu level, skills, next steps
+- `GET /api/student/skills/:skillId` - Skill details and progress
+- `POST /api/student/skills/:skillId/practice` - Record practice attempt
+- `GET /api/student/dashboard` - Dashboard data
+
+**Curriculum:**
+- `GET /api/curriculum/kyu/:level` - All modules for kyu level
+- `GET /api/curriculum/modules/:moduleId` - Module details
+- `GET /api/curriculum/tutorials/:tutorialId` - Tutorial content
+- `GET /api/curriculum/next` - Next recommended activity
+
+**Assessments:**
+- `POST /api/assessments/placement` - Take placement test
+- `POST /api/assessments/skill-check/:skillId` - Practice test
+- `POST /api/assessments/certification/:kyuLevel` - Certification test
+- `POST /api/assessments/:assessmentId/submit` - Submit answers
+- `GET /api/assessments/:assessmentId/results` - Get results
+
+**Games:**
+- `GET /api/games/recommended` - Games for current skills
+- `POST /api/games/:gameId/result` - Log game completion
+- `GET /api/games/:gameId/skills` - Which skills this game teaches
+
+**Teacher/Parent:**
+- `GET /api/teacher/students` - List of students
+- `GET /api/teacher/students/:studentId/progress` - Student progress
+- `POST /api/teacher/assignments` - Create assignment
+
+### Component Architecture
+
+**New Components Needed:**
+
+```
+/src/components/curriculum/
+  - SkillCard.tsx - Display skill with progress
+  - ModuleCard.tsx - Module overview with skills
+  - CurriculumMap.tsx - Visual map of curriculum
+  - SkillTree.tsx - Dependency graph visualization
+
+/src/components/practice/
+  - PracticeSession.tsx - Practice exercise UI
+  - ProblemDisplay.tsx - Show problem to solve
+  - AnswerInput.tsx - Accept answer (with abacus)
+  - FeedbackDisplay.tsx - Show correctness and hints
+
+/src/components/assessment/
+  - PlacementTest.tsx - Initial assessment
+  - SkillCheckTest.tsx - Practice test
+  - CertificationTest.tsx - Formal kyu test
+  - TestResults.tsx - Detailed results page
+
+/src/components/dashboard/
+  - StudentDashboard.tsx - Main dashboard
+  - ProgressOverview.tsx - Current level and progress
+  - NextActivity.tsx - Recommended next step
+  - AchievementShowcase.tsx - Badges and milestones
+  - ActivityFeed.tsx - Recent activity
+
+/src/components/teacher/
+  - TeacherDashboard.tsx
+  - StudentRoster.tsx
+  - StudentDetail.tsx
+  - AssignmentCreator.tsx
+```
+
+---
+
+## Content Creation Process
+
+### Tutorial Creation Workflow
+
+1. **Define Skill:** What specific skill does this teach?
+2. **Outline Steps:** Break down into 5-10 learning steps
+3. **Create Interactive Elements:**
+   - Which beads to highlight
+   - What movements to demonstrate
+   - Example problems
+4. **Add Explanations:** Clear, kid-friendly language
+5. **Test with Students:** Iterate based on confusion points
+6. **Publish:** Add to curriculum map
+
+### Tutorial Template
+
+```typescript
+{
+  id: "friends-of-5-intro",
+  title: "Friends of 5 - Introduction",
+  skillIds: ["friends-5-recognition"],
+  kyuLevel: 9,
+  estimatedDuration: 15,
+  steps: [
+    {
+      instruction: "Let's learn about friends of 5! These are pairs of numbers that add up to 5.",
+      problem: null,
+      highlighting: [],
+      explanation: "When you add friends together, they always make 5!"
+    },
+    {
+      instruction: "1 and 4 are friends! See how 1 + 4 = 5?",
+      problem: { operation: 'add', terms: [1, 4] },
+      highlighting: [
+        { column: 0, value: 1, direction: 'activate' },
+        { column: 0, value: 4, direction: 'up', step: 2 }
+      ],
+      explanation: "We set 1 earth bead, then add 4 more by using the heaven bead (5) and removing 1."
+    },
+    // ... more steps
+  ]
+}
+```
+
+### Practice Set Template
+
+```typescript
+{
+  id: "friends-5-practice-1",
+  skillIds: ["friends-5-recognition", "friends-5-addition"],
+  problemCount: 20,
+  timeLimit: 300, // 5 minutes
+  passingAccuracy: 0.85,
+  problemGenerator: {
+    type: 'addition',
+    numberRange: [1, 9],
+    requiresFriends5: true,
+    maxTerms: 2
+  }
+}
+```
+
+---
+
+## File Structure for Curriculum
+
+```
+/apps/web/src/curriculum/
+  /schema/
+    - skills.ts (skill definitions)
+    - modules.ts (module definitions)
+    - assessments.ts (test definitions)
+
+  /content/
+    /10-kyu/
+      - module-1-intro.ts
+      - module-2-setting-numbers.ts
+      - module-3-basic-addition.ts
+    /9-kyu/
+      - module-4-friends-5-intro.ts
+      - module-5-friends-5-application.ts
+    /8-kyu/
+      ... and so on
+
+  /tutorials/
+    /10-kyu/
+      - intro-to-abacus.ts
+      - place-value.ts
+      - setting-numbers.ts
+      - basic-addition.ts
+      - basic-subtraction.ts
+    /9-kyu/
+      - friends-5-concept.ts
+      - friends-5-addition.ts
+      - friends-5-subtraction.ts
+    ... and so on
+
+  /practice/
+    /10-kyu/
+      - number-setting-practice.ts
+      - basic-addition-practice.ts
+    /9-kyu/
+      - friends-5-practice.ts
+    ... and so on
+
+  /assessments/
+    - placement-test.ts
+    - 10-kyu-certification.ts
+    - 9-kyu-certification.ts
+    ... and so on
+
+  - curriculum-map.ts (master curriculum definition)
+  - game-skill-mappings.ts (which games teach which skills)
+```
+
+---
+
+## Next Immediate Steps
+
+### Week 1: Database Schema Design
+- [ ] Design complete schema for Phase 1
+- [ ] Write migration scripts
+- [ ] Document schema decisions
+- [ ] Review with stakeholders
+
+### Week 2-3: Content Planning
+- [ ] Write detailed 10 Kyu curriculum outline
+- [ ] Write detailed 9 Kyu curriculum outline
+- [ ] Define all skills for 10-9 Kyu
+- [ ] Map skills to existing games
+
+### Week 4-5: Tutorial Content Creation
+- [ ] Write 5 tutorials for 10 Kyu
+- [ ] Write 3 tutorials for 9 Kyu
+- [ ] Create interactive steps with highlighting
+- [ ] Add kid-friendly explanations
+
+### Week 6-7: Assessment System Build
+- [ ] Build assessment component UI
+- [ ] Implement grading engine
+- [ ] Create placement test (20 problems)
+- [ ] Create 10 Kyu certification test (30 problems)
+- [ ] Create 9 Kyu certification test (40 problems)
+
+### Week 8-9: Practice System
+- [ ] Build practice session component
+- [ ] Implement problem generator for each skill
+- [ ] Add immediate feedback system
+- [ ] Create hint system
+
+### Week 10-11: Student Dashboard
+- [ ] Design dashboard UI (kid-friendly)
+- [ ] Build progress visualization
+- [ ] Implement "next recommended activity" logic
+- [ ] Add achievement display
+
+### Week 12: Integration & Testing
+- [ ] Connect all pieces: tutorials → practice → games → assessment
+- [ ] Test complete user flow
+- [ ] User testing with kids
+- [ ] Iterate based on feedback
+
+---
+
+## Questions to Resolve
+
+1. **Certification Validity:** Should kyu certifications expire? (Traditional abacus schools: no expiration)
+2. **Retake Policy:** How many times can student retake certification test? (Suggest: unlimited, but must wait 24 hours)
+3. **Grading Standards:** Strict adherence to Japanese standards or adjust for USA context?
+4. **Physical Abacus:** Should we require physical abacus for certain levels? (Recommend: optional but encouraged)
+5. **Age Restrictions:** Any minimum age? (Suggest: 6+ with parent/teacher supervision)
+6. **Teacher Accounts:** Free for teachers? (Recommend: yes, free for teachers)
+7. **Pricing Model:** Free tier + premium? School licensing? (TBD)
+8. **Content Licensing:** Will curriculum be open source or proprietary? (Recommend: proprietary but allow teacher customization)
+9. **Accessibility:** WCAG compliance level? (Recommend: AA minimum)
+10. **Data Privacy:** COPPA compliance for users under 13? (Required: yes, must be compliant)
+
+---
+
+## Conclusion
+
+This roadmap provides a clear path from current state (scattered features) to target state (complete educational platform). The phased approach allows incremental delivery while maintaining focus on core learning experience.
+
+**Estimated Timeline:**
+- Phase 1 (10-9 Kyu MVP): 3 months
+- Phase 2 (8-5 Kyu): 5 months
+- Phase 3 (4-1 Kyu): 6 months
+- Phase 4 (Dan levels): 3 months
+- Phase 5 (Ecosystem): Ongoing
+
+**Total to Complete Platform:** ~17 months for core curriculum, then continuous improvement
+
+**Priority:** Start with Phase 1 to prove the concept, get student feedback, and validate the learning loop before building the full system.
--- a/apps/web/.claude/GAME_THEMES.md
+++ b/apps/web/.claude/GAME_THEMES.md
@@ -0,0 +1,154 @@
+# Game Theme Standardization
+
+## Problem
+
+Previously, each game manually specified `color`, `gradient`, and `borderColor` in their manifest. This led to:
+- Inconsistent appearance across game cards
+- No guidance on what colors/gradients to use
+- Easy to choose saturated colors that don't match the pastel style
+- Duplication and maintenance burden
+
+## Solution
+
+**Standard theme presets** in `/src/lib/arcade/game-themes.ts`
+
+All games now use predefined color themes that ensure consistent, professional appearance.
+
+## Usage
+
+### 1. Import from the Game SDK
+
+```typescript
+import { defineGame, getGameTheme } from '@/lib/arcade/game-sdk'
+import type { GameManifest } from '@/lib/arcade/game-sdk'
+```
+
+### 2. Use the Theme Spread Operator
+
+```typescript
+const manifest: GameManifest = {
+  name: 'my-game',
+  displayName: 'My Awesome Game',
+  icon: '🎮',
+  description: 'A fun game',
+  longDescription: 'More details...',
+  maxPlayers: 4,
+  difficulty: 'Intermediate',
+  chips: ['🎯 Feature 1', '⚡ Feature 2'],
+  ...getGameTheme('blue'),  // ← Just add this!
+  available: true,
+}
+```
+
+That's it! The theme automatically provides:
+- `color: 'blue'`
+- `gradient: 'linear-gradient(135deg, #dbeafe, #bfdbfe)'`
+- `borderColor: 'blue.200'`
+
+## Available Themes
+
+All themes use Panda CSS's 100-200 color range for soft pastel appearance:
+
+| Theme | Color Range | Use Case |
+|-------|-------------|----------|
+| `blue` | blue-100 to blue-200 | Memory, puzzle games |
+| `purple` | purple-100 to purple-200 | Strategic, battle games |
+| `green` | green-100 to green-200 | Growth, achievement games |
+| `teal` | teal-100 to teal-200 | Creative, sorting games |
+| `indigo` | indigo-100 to indigo-200 | Deep thinking games |
+| `pink` | pink-100 to pink-200 | Fun, casual games |
+| `orange` | orange-100 to orange-200 | Speed, energy games |
+| `yellow` | yellow-100 to yellow-200 | Bright, happy games |
+| `red` | red-100 to red-200 | Competition, challenge |
+| `gray` | gray-100 to gray-200 | Neutral games |
+
+## Examples
+
+### Current Games
+
+```typescript
+// Memory Lightning - blue theme
+...getGameTheme('blue')
+
+// Matching Pairs Battle - purple theme
+...getGameTheme('purple')
+
+// Card Sorting Challenge - teal theme
+...getGameTheme('teal')
+
+// Speed Complement Race - blue theme
+...getGameTheme('blue')
+```
+
+## Benefits
+
+✅ **Consistency** - All games have the same professional pastel look
+✅ **Simple** - One line instead of three properties
+✅ **Maintainable** - Update all games by changing the theme definition
+✅ **Discoverable** - TypeScript autocomplete shows available themes
+✅ **No mistakes** - Can't accidentally use wrong color values
+
+## Advanced Usage
+
+If you need to inspect or customize a theme:
+
+```typescript
+import { GAME_THEMES } from '@/lib/arcade/game-sdk'
+import type { GameTheme } from '@/lib/arcade/game-sdk'
+
+// Access a specific theme
+const blueTheme: GameTheme = GAME_THEMES.blue
+
+// Use it
+const manifest: GameManifest = {
+  // ... other fields
+  ...blueTheme,
+  // Or customize:
+  color: blueTheme.color,
+  gradient: 'linear-gradient(135deg, #custom, #values)', // override
+  borderColor: blueTheme.borderColor,
+}
+```
+
+## Adding New Themes
+
+To add a new theme, edit `/src/lib/arcade/game-themes.ts`:
+
+```typescript
+export const GAME_THEMES = {
+  // ... existing themes
+  mycolor: {
+    color: 'mycolor',
+    gradient: 'linear-gradient(135deg, #lighter, #darker)', // Use Panda CSS 100-200 range
+    borderColor: 'mycolor.200',
+  },
+} as const satisfies Record<string, GameTheme>
+```
+
+Then update the TypeScript type:
+```typescript
+export type GameThemeName = keyof typeof GAME_THEMES
+```
+
+## Migration Checklist
+
+When creating a new game:
+
+- [x] Import `getGameTheme` from `@/lib/arcade/game-sdk`
+- [x] Use `...getGameTheme('theme-name')` in manifest
+- [x] Remove manual `color`, `gradient`, `borderColor` properties
+- [x] Choose a theme that matches your game's vibe
+
+## Summary
+
+**Old way** (error-prone, inconsistent):
+```typescript
+color: 'teal',
+gradient: 'linear-gradient(135deg, #99f6e4, #5eead4)',  // Too saturated!
+borderColor: 'teal.200',
+```
+
+**New way** (simple, consistent):
+```typescript
+...getGameTheme('teal')
+```
--- a/apps/web/.claude/TUTORIAL_SYSTEM.md
+++ b/apps/web/.claude/TUTORIAL_SYSTEM.md
@@ -0,0 +1,222 @@
+# Tutorial System Documentation
+
+## Overview
+
+The tutorial system is a sophisticated interactive learning platform for teaching soroban abacus concepts. It features step-by-step guidance, bead highlighting, pedagogical decomposition, and progress tracking.
+
+## Key Components
+
+### 1. TutorialPlayer (`/src/components/tutorial/TutorialPlayer.tsx`)
+The main tutorial playback component that:
+- Displays tutorial steps progressively
+- Highlights specific beads users should interact with
+- Provides real-time feedback and tooltips
+- Shows step-by-step instructions for multi-step operations
+- Tracks user progress through the tutorial
+- Auto-advances to next step on correct completion
+
+**Key Features:**
+- **Bead Highlighting**: Visual indicators showing which beads to manipulate
+- **Step Progress**: Shows current step out of total steps
+- **Error Feedback**: Provides hints when user makes mistakes
+- **Multi-Step Support**: Breaks complex operations into sequential sub-steps
+- **Pedagogical Decomposition**: Explains the "why" behind each operation
+
+### 2. TutorialEditor (`/src/components/tutorial/TutorialEditor.tsx`)
+A full-featured editor for creating and editing tutorials:
+- Visual step editor
+- Bead highlight configuration
+- Multi-step instruction editor
+- Live preview
+- Import/export functionality
+- Access control
+
+**Editor URL:** `/tutorial-editor`
+
+### 3. Tutorial Data Structure (`/src/types/tutorial.ts`)
+
+```typescript
+interface Tutorial {
+  id: string
+  title: string
+  description: string
+  category: string
+  difficulty: 'beginner' | 'intermediate' | 'advanced'
+  estimatedDuration: number // minutes
+  steps: TutorialStep[]
+  tags: string[]
+  author: string
+  version: string
+  createdAt: Date
+  updatedAt: Date
+  isPublished: boolean
+}
+
+interface TutorialStep {
+  id: string
+  title: string
+  problem: string                    // e.g. "2 + 3"
+  description: string                // User-facing explanation
+  startValue: number                 // Initial abacus value
+  targetValue: number                // Goal value
+  expectedAction: 'add' | 'remove' | 'multi-step'
+  actionDescription: string
+
+  // Bead highlighting
+  highlightBeads?: Array<{
+    placeValue: number               // 0=ones, 1=tens, etc.
+    beadType: 'heaven' | 'earth'
+    position?: number                // For earth beads: 0-3
+  }>
+
+  // Progressive step highlighting
+  stepBeadHighlights?: Array<{
+    placeValue: number
+    beadType: 'heaven' | 'earth'
+    position?: number
+    stepIndex: number                // Which instruction step
+    direction: 'up' | 'down' | 'activate' | 'deactivate'
+    order?: number                   // Order within step
+  }>
+
+  totalSteps?: number                // For multi-step operations
+  multiStepInstructions?: string[]   // Sequential instructions
+
+  // Tooltips and guidance
+  tooltip: {
+    content: string                  // Short title
+    explanation: string              // Detailed explanation
+  }
+}
+```
+
+### 4. Tutorial Converter (`/src/utils/tutorialConverter.ts`)
+
+Utility that converts the original `GuidedAdditionTutorial` data into the new tutorial format:
+- `guidedAdditionSteps`: Array of tutorial steps from basic addition to complements
+- `convertGuidedAdditionTutorial()`: Converts to Tutorial object
+- `getTutorialForEditor()`: Main export used in the app
+
+**Current Tutorial Steps:**
+1. Basic Addition (0+1, 1+1, 2+1, 3+1)
+2. Heaven Bead Introduction (0+5, 5+1)
+3. Five Complements (3+4, 2+3 using 5-complement method)
+4. Complex Operations (6+2, 7+4 with carrying)
+
+### 5. Supporting Utilities
+
+**`/src/utils/abacusInstructionGenerator.ts`**
+- Automatically generates step-by-step instructions from start/target values
+- Creates bead highlight data
+- Determines movement directions
+
+**`/src/utils/beadDiff.ts`**
+- Calculates differences between abacus states
+- Generates visual feedback tooltips
+- Explains what changed and why
+
+## Usage Examples
+
+### Basic Usage in a Page
+
+```typescript
+import { TutorialPlayer } from '@/components/tutorial/TutorialPlayer'
+import { getTutorialForEditor } from '@/utils/tutorialConverter'
+
+export function MyPage() {
+  return (
+    <TutorialPlayer
+      tutorial={getTutorialForEditor()}
+      isDebugMode={false}
+      showDebugPanel={false}
+    />
+  )
+}
+```
+
+### Using a Subset of Steps
+
+```typescript
+import { getTutorialForEditor } from '@/utils/tutorialConverter'
+
+const fullTutorial = getTutorialForEditor()
+
+// Extract specific steps (e.g., just "Friends of 5")
+const friendsOf5Tutorial = {
+  ...fullTutorial,
+  id: 'friends-of-5-demo',
+  title: 'Friends of 5',
+  steps: fullTutorial.steps.filter(step =>
+    step.id === 'complement-2' // The 2+3=5 step
+  )
+}
+
+return <TutorialPlayer tutorial={friendsOf5Tutorial} />
+```
+
+### Creating a Custom Tutorial
+
+```typescript
+const customTutorial: Tutorial = {
+  id: 'my-tutorial',
+  title: 'My Custom Tutorial',
+  description: 'Learning something new',
+  category: 'Custom',
+  difficulty: 'beginner',
+  estimatedDuration: 5,
+  steps: [
+    {
+      id: 'step-1',
+      title: 'Add 2',
+      problem: '0 + 2',
+      description: 'Move two earth beads up',
+      startValue: 0,
+      targetValue: 2,
+      expectedAction: 'add',
+      actionDescription: 'Add two earth beads',
+      highlightBeads: [
+        { placeValue: 0, beadType: 'earth', position: 0 },
+        { placeValue: 0, beadType: 'earth', position: 1 }
+      ],
+      tooltip: {
+        content: 'Adding 2',
+        explanation: 'Push two earth beads up to represent 2'
+      }
+    }
+  ],
+  tags: ['custom'],
+  author: 'Me',
+  version: '1.0.0',
+  createdAt: new Date(),
+  updatedAt: new Date(),
+  isPublished: true
+}
+```
+
+## Current Implementation Locations
+
+**Live Tutorials:**
+- `/guide` - Second tab "Arithmetic Operations" contains the full guided addition tutorial
+
+**Editor:**
+- `/tutorial-editor` - Full tutorial editing interface
+
+**Storybook:**
+- Multiple tutorial stories in `/src/components/tutorial/*.stories.tsx`
+
+## Key Design Principles
+
+1. **Progressive Disclosure**: Users see one step at a time
+2. **Immediate Feedback**: Real-time validation and hints
+3. **Visual Guidance**: Bead highlighting shows exactly what to do
+4. **Pedagogical Decomposition**: Multi-step operations broken into atomic actions
+5. **Auto-Advancement**: Successful completion automatically moves to next step
+6. **Error Recovery**: Helpful hints when user makes mistakes
+
+## Notes
+
+- The tutorial system uses the existing `AbacusReact` component
+- Tutorials can be created/edited through the TutorialEditor
+- Tutorial data can be exported/imported as JSON
+- The system supports both single-step and multi-step operations
+- Bead highlighting uses place value indexing (0=ones, 1=tens, etc.)
--- a/apps/web/.claude/UI_STYLE_GUIDE.md
+++ b/apps/web/.claude/UI_STYLE_GUIDE.md
@@ -0,0 +1,94 @@
+# UI Style Guide
+
+## Confirmations and Dialogs
+
+**NEVER use native browser dialogs:**
+- ❌ `alert()`
+- ❌ `confirm()`
+- ❌ `prompt()`
+
+**ALWAYS use inline React-based confirmations:**
+- Show confirmation UI in-place using React state
+- Provide Cancel and Confirm buttons
+- Use descriptive warning messages with appropriate emoji (⚠️)
+- Follow the Panda CSS styling system
+- Match the visual style of the surrounding UI
+
+### Pattern: Inline Confirmation
+
+```typescript
+const [confirming, setConfirming] = useState(false)
+
+{!confirming ? (
+  <button onClick={() => setConfirming(true)}>
+    Delete Item
+  </button>
+) : (
+  <div>
+    <div style={{ /* warning styling */ }}>
+      ⚠️ Are you sure you want to delete this item?
+    </div>
+    <div style={{ /* description styling */ }}>
+      This action cannot be undone.
+    </div>
+    <div style={{ display: 'flex', gap: '8px' }}>
+      <button onClick={() => setConfirming(false)}>
+        Cancel
+      </button>
+      <button onClick={handleDelete}>
+        Confirm Delete
+      </button>
+    </div>
+  </div>
+)}
+```
+
+### Real Examples
+
+See `/src/components/nav/ModerationPanel.tsx` for production examples:
+- Transfer ownership confirmation (lines 1793-1929)
+- Unban user confirmation (shows inline warning with Cancel/Confirm)
+
+### Why This Pattern?
+
+1. **Consistency**: Native dialogs look different across browsers and platforms
+2. **Control**: We can style, position, and enhance confirmations to match our design
+3. **Accessibility**: We can add proper ARIA attributes and keyboard navigation
+4. **UX**: Users stay in context rather than being interrupted by modal dialogs
+5. **Testing**: Inline confirmations are easier to test than native browser dialogs
+
+### Migration Checklist
+
+When replacing native dialogs:
+- [ ] Add state variable for confirmation (e.g., `const [confirming, setConfirming] = useState(false)`)
+- [ ] Remove the `confirm()` or `alert()` call from the handler
+- [ ] Replace the original UI with conditional rendering
+- [ ] Show initial state with primary action button
+- [ ] Show confirmation state with warning message + Cancel/Confirm buttons
+- [ ] Ensure Cancel button resets state: `onClick={() => setConfirming(false)}`
+- [ ] Ensure Confirm button performs action and resets state
+- [ ] Add loading states if the action is async
+- [ ] Style to match surrounding UI using Panda CSS
+
+## Styling System
+
+This project uses **Panda CSS**, not Tailwind CSS.
+
+- ❌ Never use Tailwind utility classes (e.g., `className="bg-blue-500"`)
+- ✅ Always use Panda CSS `css()` function
+- ✅ Use Panda's token system (defined in `panda.config.ts`)
+
+See `.claude/CLAUDE.md` for complete Panda CSS documentation.
+
+## Emoji Usage
+
+Emojis are used liberally throughout the UI for visual communication:
+- 👑 Host/owner status
+- ⏳ Waiting states
+- ⚠️ Warnings and confirmations
+- ✅ Success states
+- ❌ Error states
+- 👀 Spectating mode
+- 🎮 Gaming context
+
+Use emojis to enhance clarity, not replace text.
--- a/apps/web/.claude/settings.local.json
+++ b/apps/web/.claude/settings.local.json
@@ -97,7 +97,13 @@
      "Bash(pnpm exec turbo build --filter=@soroban/web)",
      "Bash(do gh run list --limit 1 --json conclusion,status,name,databaseId --jq '.[0] | \"\"\\(.status) - \\(.conclusion // \"\"running\"\")\"\"')",
      "Bash(do gh run list --limit 1 --json conclusion,status,name --jq '.[0] | \"\"\\(.status) - \\(.conclusion // \"\"running\"\") - \\(.name)\"\"')",
-      "Bash(do gh run list --limit 1 --workflow=\"Build and Deploy\" --json conclusion,status --jq '.[0] | \"\"\\(.status) - \\(.conclusion // \"\"running\"\")\"\"')"
+      "Bash(do gh run list --limit 1 --workflow=\"Build and Deploy\" --json conclusion,status --jq '.[0] | \"\"\\(.status) - \\(.conclusion // \"\"running\"\")\"\"')",
+      "WebFetch(domain:abaci.one)",
+      "Bash(do gh run list --limit 1 --workflow=\"Build and Deploy\" --json conclusion,status,databaseId --jq '.[0] | \"\"\\(.status) - \\(.conclusion // \"\"running\"\") - Run ID: \\(.databaseId)\"\"')",
+      "Bash(node -e:*)",
+      "Bash(do gh run list --limit 1 --workflow=\"Build and Deploy\" --json conclusion,status,databaseId --jq '.[0] | \"\"\\(.status) - \\(.conclusion // \"\"running\"\") - Run \\(.databaseId)\"\"')",
+      "Bash(do ssh nas.home.network '/usr/local/bin/docker inspect soroban-abacus-flashcards --format=\"\"{{index .Config.Labels \\\"\"org.opencontainers.image.revision\\\"\"}}\"\"')",
+      "Bash(git rev-parse HEAD)"
    ],
    "deny": [],
    "ask": []
--- a/apps/web/scripts/generate-build-info.js
+++ b/apps/web/scripts/generate-build-info.js
@@ -18,11 +18,14 @@ function exec(command) {
 }

 function getBuildInfo() {
-  const gitCommit = exec('git rev-parse HEAD')
-  const gitCommitShort = exec('git rev-parse --short HEAD')
-  const gitBranch = exec('git rev-parse --abbrev-ref HEAD')
-  const gitTag = exec('git describe --tags --exact-match 2>/dev/null')
-  const gitDirty = exec('git diff --quiet || echo "dirty"') === 'dirty'
+  // Try to get git info from environment variables first (for Docker builds)
+  // Fall back to git commands (for local development)
+  const gitCommit = process.env.GIT_COMMIT || exec('git rev-parse HEAD')
+  const gitCommitShort = process.env.GIT_COMMIT_SHORT || exec('git rev-parse --short HEAD')
+  const gitBranch = process.env.GIT_BRANCH || exec('git rev-parse --abbrev-ref HEAD')
+  const gitTag = process.env.GIT_TAG || exec('git describe --tags --exact-match 2>/dev/null')
+  const gitDirty =
+    process.env.GIT_DIRTY === 'true' || exec('git diff --quiet || echo "dirty"') === 'dirty'

  const packageJson = require('../package.json')

--- a/apps/web/src/app/arcade-rooms/[roomId]/page.tsx
+++ b/apps/web/src/app/arcade-rooms/[roomId]/page.tsx
@@ -158,7 +158,7 @@ export default function RoomDetailPage() {
  const startGame = () => {
    if (!room) return
    // Navigate to the room game page
-    router.push('/arcade/room')
+    router.push('/arcade')
  }

  const joinRoom = async () => {
--- a/apps/web/src/app/arcade/page.tsx
+++ b/apps/web/src/app/arcade/page.tsx
@@ -1,128 +1,409 @@
 'use client'

-import { useEffect, useRef } from 'react'
+import { useRouter } from 'next/navigation'
+import { useState } from 'react'
+import { useRoomData, useSetRoomGame } from '@/hooks/useRoomData'
+import { useViewerId } from '@/hooks/useViewerId'
+import { GAMES_CONFIG } from '@/components/GameSelector'
+import type { GameType } from '@/components/GameSelector'
 import { PageWithNav } from '@/components/PageWithNav'
 import { css } from '../../../styled-system/css'
-import { EnhancedChampionArena } from '../../components/EnhancedChampionArena'
-import { FullscreenProvider, useFullscreen } from '../../contexts/FullscreenContext'
+import { getAllGames, getGame, hasGame } from '@/lib/arcade/game-registry'

-function ArcadeContent() {
-  const { setFullscreenElement } = useFullscreen()
-  const arcadeRef = useRef<HTMLDivElement>(null)
+/**
+ * /arcade - Renders the game for the user's current room
+ * Since users can only be in one room at a time, this is a simple singular route
+ *
+ * Shows game selection when no game is set, then shows the game itself once selected.
+ * URL never changes - it's always /arcade regardless of selection, setup, or gameplay.
+ *
+ * Note: We show a friendly message with a link if no room exists to avoid navigation loops.
+ *
+ * Note: ModerationNotifications is handled by PageWithNav inside each game component,
+ * so we don't need to render it here.
+ */
+export default function RoomPage() {
+  const router = useRouter()
+  const { roomData, isLoading } = useRoomData()
+  const { data: viewerId } = useViewerId()
+  const { mutate: setRoomGame } = useSetRoomGame()
+  const [permissionError, setPermissionError] = useState<string | null>(null)

-  useEffect(() => {
-    // Register this component's main div as the fullscreen element
-    if (arcadeRef.current) {
-      setFullscreenElement(arcadeRef.current)
-    }
-  }, [setFullscreenElement])
-
-  return (
-    <div
-      ref={arcadeRef}
-      className={css({
-        minHeight: 'calc(100vh - 80px)', // Account for mini nav height
-        background: 'linear-gradient(135deg, #0f0f23 0%, #1a1a3a 50%, #2d1b69 100%)',
-        position: 'relative',
-        overflow: 'hidden',
-        display: 'flex',
-        flexDirection: 'column',
-        py: { base: '4', md: '6' },
-      })}
-    >
-      {/* Animated background elements */}
+  // Show loading state
+  if (isLoading) {
+    return (
      <div
-        className={css({
-          position: 'absolute',
-          top: 0,
-          left: 0,
-          right: 0,
-          bottom: 0,
-          backgroundImage: `
-          radial-gradient(circle at 20% 80%, rgba(120, 119, 198, 0.3) 0%, transparent 50%),
-          radial-gradient(circle at 80% 20%, rgba(255, 119, 198, 0.3) 0%, transparent 50%),
-          radial-gradient(circle at 40% 40%, rgba(120, 219, 255, 0.2) 0%, transparent 50%)
-        `,
-          animation: 'arcadeFloat 20s ease-in-out infinite',
-        })}
-      />
-
-      {/* Main Champion Arena - takes remaining space */}
-      <div
-        className={css({
-          flex: 1,
+        style={{
          display: 'flex',
-          px: { base: '2', md: '4' },
-          position: 'relative',
-          zIndex: 1,
-          minHeight: 0, // Important for flex children
-        })}
+          alignItems: 'center',
+          justifyContent: 'center',
+          height: '100vh',
+          fontSize: '18px',
+          color: '#666',
+        }}
      >
-        <EnhancedChampionArena
-          onConfigurePlayer={() => {}}
+        Loading room...
+      </div>
+    )
+  }
+
+  // Show error if no room (instead of redirecting)
+  if (!roomData) {
+    return (
+      <div
+        style={{
+          display: 'flex',
+          flexDirection: 'column',
+          alignItems: 'center',
+          justifyContent: 'center',
+          height: '100vh',
+          fontSize: '18px',
+          color: '#666',
+          gap: '1rem',
+        }}
+      >
+        <div>No active room found</div>
+        <a
+          href="/arcade"
+          style={{
+            color: '#3b82f6',
+            textDecoration: 'underline',
+          }}
+        >
+          Go to Champion Arena
+        </a>
+      </div>
+    )
+  }
+
+  // Show game selection if no game is set
+  if (!roomData.gameName) {
+    // Determine if current user is the host
+    const currentMember = roomData.members.find((m) => m.userId === viewerId)
+    const isHost = currentMember?.isCreator === true
+    const hostMember = roomData.members.find((m) => m.isCreator)
+
+    const handleGameSelect = (gameType: GameType) => {
+      console.log('[RoomPage] handleGameSelect called with gameType:', gameType)
+
+      // Check if user is host before allowing selection
+      if (!isHost) {
+        setPermissionError(
+          `Only the room host can select a game. Ask ${hostMember?.displayName || 'the host'} to choose.`
+        )
+        // Clear error after 5 seconds
+        setTimeout(() => setPermissionError(null), 5000)
+        return
+      }
+
+      // Clear any previous errors
+      setPermissionError(null)
+
+      // All games are now in the registry
+      if (hasGame(gameType)) {
+        const gameDef = getGame(gameType)
+        if (!gameDef?.manifest.available) {
+          console.log('[RoomPage] Registry game not available, blocking selection')
+          return
+        }
+
+        console.log('[RoomPage] Selecting registry game:', gameType)
+        setRoomGame(
+          {
+            roomId: roomData.id,
+            gameName: gameType,
+          },
+          {
+            onError: (error: any) => {
+              console.error('[RoomPage] Failed to set game:', error)
+              setPermissionError(
+                error.message || 'Failed to select game. Only the host can change games.'
+              )
+              setTimeout(() => setPermissionError(null), 5000)
+            },
+          }
+        )
+        return
+      }
+
+      console.log('[RoomPage] Unknown game type:', gameType)
+    }
+
+    return (
+      <PageWithNav
+        navTitle="Choose Game"
+        navEmoji="🎮"
+        emphasizePlayerSelection={true}
+        onExitSession={() => router.push('/arcade')}
+      >
+        <div
          className={css({
-            width: '100%',
-            height: '100%',
-            background: 'rgba(255, 255, 255, 0.05)',
-            backdropFilter: 'blur(20px)',
-            border: '1px solid rgba(255, 255, 255, 0.1)',
-            boxShadow: '0 20px 40px rgba(0, 0, 0, 0.3)',
+            minHeight: '100vh',
+            background: 'linear-gradient(135deg, #0f0f23 0%, #1a1a3a 50%, #2d1b69 100%)',
            display: 'flex',
            flexDirection: 'column',
+            alignItems: 'center',
+            justifyContent: 'center',
+            padding: '4',
          })}
-        />
-      </div>
-    </div>
-  )
-}
+        >
+          <h1
+            className={css({
+              fontSize: { base: '2xl', md: '3xl' },
+              fontWeight: 'bold',
+              color: 'white',
+              mb: '4',
+              textAlign: 'center',
+            })}
+          >
+            Choose a Game
+          </h1>

-function ArcadePageWithRedirect() {
-  return (
-    <PageWithNav navTitle="Champion Arena" navEmoji="🏟️" emphasizePlayerSelection={true}>
-      <ArcadeContent />
-    </PageWithNav>
-  )
-}
+          {/* Host info and permission messaging */}
+          <div
+            className={css({
+              maxWidth: '800px',
+              width: '100%',
+              mb: '6',
+            })}
+          >
+            {isHost ? (
+              <div
+                className={css({
+                  background: 'rgba(34, 197, 94, 0.1)',
+                  border: '1px solid rgba(34, 197, 94, 0.3)',
+                  borderRadius: '8px',
+                  padding: '12px 16px',
+                  color: '#86efac',
+                  fontSize: 'sm',
+                  textAlign: 'center',
+                })}
+              >
+                👑 You're the room host. Select a game to start playing.
+              </div>
+            ) : (
+              <div
+                className={css({
+                  background: 'rgba(234, 179, 8, 0.1)',
+                  border: '1px solid rgba(234, 179, 8, 0.3)',
+                  borderRadius: '8px',
+                  padding: '12px 16px',
+                  color: '#fde047',
+                  fontSize: 'sm',
+                  textAlign: 'center',
+                })}
+              >
+                ⏳ Waiting for {hostMember?.displayName || 'the host'} to select a game...
+              </div>
+            )}

-export default function ArcadePage() {
-  return (
-    <FullscreenProvider>
-      <ArcadePageWithRedirect />
-    </FullscreenProvider>
-  )
-}
+            {/* Permission error message */}
+            {permissionError && (
+              <div
+                className={css({
+                  background: 'rgba(239, 68, 68, 0.1)',
+                  border: '1px solid rgba(239, 68, 68, 0.3)',
+                  borderRadius: '8px',
+                  padding: '12px 16px',
+                  color: '#fca5a5',
+                  fontSize: 'sm',
+                  textAlign: 'center',
+                  mt: '3',
+                })}
+              >
+                ⚠️ {permissionError}
+              </div>
+            )}
+          </div>

-// Arcade-specific animations
-const arcadeAnimations = `
-@keyframes arcadeFloat {
-  0%, 100% {
-    transform: translateY(0px) rotate(0deg);
-    opacity: 0.7;
+          <div
+            className={css({
+              display: 'grid',
+              gridTemplateColumns: { base: '1fr', md: 'repeat(2, 1fr)' },
+              gap: '4',
+              maxWidth: '800px',
+              width: '100%',
+            })}
+          >
+            {/* Legacy games */}
+            {Object.entries(GAMES_CONFIG).map(([gameType, config]: [string, any]) => {
+              const isAvailable = !('available' in config) || config.available !== false
+              const isDisabled = !isHost || !isAvailable
+              return (
+                <button
+                  key={gameType}
+                  onClick={() => handleGameSelect(gameType as GameType)}
+                  disabled={isDisabled}
+                  className={css({
+                    background: config.gradient,
+                    border: '2px solid',
+                    borderColor: config.borderColor || 'blue.200',
+                    borderRadius: '2xl',
+                    padding: '6',
+                    cursor: isDisabled ? 'not-allowed' : 'pointer',
+                    opacity: isDisabled ? 0.4 : 1,
+                    transition: 'all 0.3s ease',
+                    _hover: isDisabled
+                      ? {}
+                      : {
+                          transform: 'translateY(-4px) scale(1.02)',
+                          boxShadow: '0 20px 40px rgba(59, 130, 246, 0.2)',
+                        },
+                  })}
+                >
+                  <div
+                    className={css({
+                      fontSize: '4xl',
+                      mb: '2',
+                    })}
+                  >
+                    {config.icon}
+                  </div>
+                  <h3
+                    className={css({
+                      fontSize: 'xl',
+                      fontWeight: 'bold',
+                      color: 'gray.900',
+                      mb: '2',
+                    })}
+                  >
+                    {config.name}
+                  </h3>
+                  <p
+                    className={css({
+                      fontSize: 'sm',
+                      color: 'gray.600',
+                    })}
+                  >
+                    {config.description}
+                  </p>
+                </button>
+              )
+            })}
+
+            {/* Registry games */}
+            {getAllGames().map((gameDef) => {
+              const isAvailable = gameDef.manifest.available
+              const isDisabled = !isHost || !isAvailable
+              return (
+                <button
+                  key={gameDef.manifest.name}
+                  onClick={() => handleGameSelect(gameDef.manifest.name)}
+                  disabled={isDisabled}
+                  style={{
+                    background: gameDef.manifest.gradient,
+                    borderColor: gameDef.manifest.borderColor,
+                  }}
+                  className={css({
+                    border: '2px solid',
+                    borderRadius: '2xl',
+                    padding: '6',
+                    cursor: isDisabled ? 'not-allowed' : 'pointer',
+                    opacity: isDisabled ? 0.4 : 1,
+                    transition: 'all 0.3s ease',
+                    _hover: isDisabled
+                      ? {}
+                      : {
+                          transform: 'translateY(-4px) scale(1.02)',
+                          boxShadow: '0 20px 40px rgba(59, 130, 246, 0.2)',
+                        },
+                  })}
+                >
+                  <div
+                    className={css({
+                      fontSize: '4xl',
+                      mb: '2',
+                    })}
+                  >
+                    {gameDef.manifest.icon}
+                  </div>
+                  <h3
+                    className={css({
+                      fontSize: 'xl',
+                      fontWeight: 'bold',
+                      color: 'gray.900',
+                      mb: '2',
+                    })}
+                  >
+                    {gameDef.manifest.displayName}
+                  </h3>
+                  <p
+                    className={css({
+                      fontSize: 'sm',
+                      color: 'gray.600',
+                    })}
+                  >
+                    {gameDef.manifest.description}
+                  </p>
+                </button>
+              )
+            })}
+          </div>
+        </div>
+      </PageWithNav>
+    )
  }
-  33% {
-    transform: translateY(-20px) rotate(1deg);
-    opacity: 1;
+
+  // Check if this is a registry game first
+  if (hasGame(roomData.gameName)) {
+    const gameDef = getGame(roomData.gameName)
+    if (!gameDef) {
+      return (
+        <PageWithNav
+          navTitle="Game Not Found"
+          navEmoji="⚠️"
+          emphasizePlayerSelection={true}
+          onExitSession={() => router.push('/arcade')}
+        >
+          <div
+            style={{
+              display: 'flex',
+              alignItems: 'center',
+              justifyContent: 'center',
+              height: '100vh',
+              fontSize: '18px',
+              color: '#666',
+            }}
+          >
+            Game "{roomData.gameName}" not found in registry
+          </div>
+        </PageWithNav>
+      )
+    }
+
+    // Render registry game dynamically
+    const { Provider, GameComponent } = gameDef
+    return (
+      <Provider>
+        <GameComponent />
+      </Provider>
+    )
  }
-  66% {
-    transform: translateY(-10px) rotate(-1deg);
-    opacity: 0.8;
+
+  // Render legacy games based on room's gameName
+  switch (roomData.gameName) {
+    // TODO: Add other legacy games (complement-race, etc.) once migrated
+    default:
+      return (
+        <PageWithNav
+          navTitle="Game Not Available"
+          navEmoji="⚠️"
+          emphasizePlayerSelection={true}
+          onExitSession={() => router.push('/arcade')}
+        >
+          <div
+            style={{
+              display: 'flex',
+              alignItems: 'center',
+              justifyContent: 'center',
+              height: '100vh',
+              fontSize: '18px',
+              color: '#666',
+            }}
+          >
+            Game "{roomData.gameName}" not yet supported
+          </div>
+        </PageWithNav>
+      )
  }
 }
-
-@keyframes arcadePulse {
-  0%, 100% {
-    box-shadow: 0 0 20px rgba(96, 165, 250, 0.3);
-  }
-  50% {
-    box-shadow: 0 0 40px rgba(96, 165, 250, 0.6);
-  }
-}
-`
-
-// Inject arcade animations
-if (typeof document !== 'undefined' && !document.getElementById('arcade-animations')) {
-  const style = document.createElement('style')
-  style.id = 'arcade-animations'
-  style.textContent = arcadeAnimations
-  document.head.appendChild(style)
-}
--- a/apps/web/src/app/arcade/room/page.tsx
+++ b/apps/web/src/app/arcade/room/page.tsx
@@ -1,358 +0,0 @@
-'use client'
-
-import { useRouter } from 'next/navigation'
-import { useRoomData, useSetRoomGame } from '@/hooks/useRoomData'
-import { GAMES_CONFIG } from '@/components/GameSelector'
-import type { GameType } from '@/components/GameSelector'
-import { PageWithNav } from '@/components/PageWithNav'
-import { css } from '../../../../styled-system/css'
-import { getAllGames, getGame, hasGame } from '@/lib/arcade/game-registry'
-
-// Map GameType keys to internal game names
-// Note: "battle-arena" removed - now handled by game registry as "matching"
-const GAME_TYPE_TO_NAME: Record<GameType, string> = {
-  'complement-race': 'complement-race',
-  'master-organizer': 'master-organizer',
-}
-
-/**
- * /arcade/room - Renders the game for the user's current room
- * Since users can only be in one room at a time, this is a simple singular route
- *
- * Shows game selection when no game is set, then shows the game itself once selected.
- * URL never changes - it's always /arcade/room regardless of selection, setup, or gameplay.
- *
- * Note: We don't redirect to /arcade if no room exists to avoid navigation loops.
- * Instead, we show a friendly message with a link back to the Champion Arena.
- *
- * Note: ModerationNotifications is handled by PageWithNav inside each game component,
- * so we don't need to render it here.
- */
-export default function RoomPage() {
-  const router = useRouter()
-  const { roomData, isLoading } = useRoomData()
-  const { mutate: setRoomGame } = useSetRoomGame()
-
-  // Show loading state
-  if (isLoading) {
-    return (
-      <div
-        style={{
-          display: 'flex',
-          alignItems: 'center',
-          justifyContent: 'center',
-          height: '100vh',
-          fontSize: '18px',
-          color: '#666',
-        }}
-      >
-        Loading room...
-      </div>
-    )
-  }
-
-  // Show error if no room (instead of redirecting)
-  if (!roomData) {
-    return (
-      <div
-        style={{
-          display: 'flex',
-          flexDirection: 'column',
-          alignItems: 'center',
-          justifyContent: 'center',
-          height: '100vh',
-          fontSize: '18px',
-          color: '#666',
-          gap: '1rem',
-        }}
-      >
-        <div>No active room found</div>
-        <a
-          href="/arcade"
-          style={{
-            color: '#3b82f6',
-            textDecoration: 'underline',
-          }}
-        >
-          Go to Champion Arena
-        </a>
-      </div>
-    )
-  }
-
-  // Show game selection if no game is set
-  if (!roomData.gameName) {
-    const handleGameSelect = (gameType: GameType) => {
-      console.log('[RoomPage] handleGameSelect called with gameType:', gameType)
-
-      // Check if it's a registry game first
-      if (hasGame(gameType)) {
-        const gameDef = getGame(gameType)
-        if (!gameDef?.manifest.available) {
-          console.log('[RoomPage] Registry game not available, blocking selection')
-          return
-        }
-
-        console.log('[RoomPage] Selecting registry game:', gameType)
-        setRoomGame({
-          roomId: roomData.id,
-          gameName: gameType, // Use the game name directly for registry games
-        })
-        return
-      }
-
-      // Legacy game handling
-      const gameConfig = GAMES_CONFIG[gameType as keyof typeof GAMES_CONFIG]
-      if (!gameConfig) {
-        console.log('[RoomPage] Unknown game type:', gameType)
-        return
-      }
-
-      console.log('[RoomPage] Game config:', {
-        name: gameConfig.name,
-        available: 'available' in gameConfig ? gameConfig.available : true,
-      })
-
-      if ('available' in gameConfig && gameConfig.available === false) {
-        console.log('[RoomPage] Game not available, blocking selection')
-        return // Don't allow selecting unavailable games
-      }
-
-      // Map GameType to internal game name
-      const internalGameName = GAME_TYPE_TO_NAME[gameType]
-      console.log('[RoomPage] Mapping:', {
-        gameType,
-        internalGameName,
-        mappingExists: !!internalGameName,
-      })
-
-      console.log('[RoomPage] Calling setRoomGame with:', {
-        roomId: roomData.id,
-        gameName: internalGameName,
-        preservingGameConfig: true,
-      })
-
-      // Don't pass gameConfig - we want to preserve existing settings for all games
-      setRoomGame({
-        roomId: roomData.id,
-        gameName: internalGameName,
-      })
-    }
-
-    return (
-      <PageWithNav
-        navTitle="Choose Game"
-        navEmoji="🎮"
-        emphasizePlayerSelection={true}
-        onExitSession={() => router.push('/arcade')}
-      >
-        <div
-          className={css({
-            minHeight: '100vh',
-            background: 'linear-gradient(135deg, #0f0f23 0%, #1a1a3a 50%, #2d1b69 100%)',
-            display: 'flex',
-            flexDirection: 'column',
-            alignItems: 'center',
-            justifyContent: 'center',
-            padding: '4',
-          })}
-        >
-          <h1
-            className={css({
-              fontSize: { base: '2xl', md: '3xl' },
-              fontWeight: 'bold',
-              color: 'white',
-              mb: '8',
-              textAlign: 'center',
-            })}
-          >
-            Choose a Game
-          </h1>
-
-          <div
-            className={css({
-              display: 'grid',
-              gridTemplateColumns: { base: '1fr', md: 'repeat(2, 1fr)' },
-              gap: '4',
-              maxWidth: '800px',
-              width: '100%',
-            })}
-          >
-            {/* Legacy games */}
-            {Object.entries(GAMES_CONFIG).map(([gameType, config]) => {
-              const isAvailable = !('available' in config) || config.available !== false
-              return (
-                <button
-                  key={gameType}
-                  onClick={() => handleGameSelect(gameType as GameType)}
-                  disabled={!isAvailable}
-                  className={css({
-                    background: config.gradient,
-                    border: '2px solid',
-                    borderColor: config.borderColor || 'blue.200',
-                    borderRadius: '2xl',
-                    padding: '6',
-                    cursor: !isAvailable ? 'not-allowed' : 'pointer',
-                    opacity: !isAvailable ? 0.5 : 1,
-                    transition: 'all 0.3s ease',
-                    _hover: !isAvailable
-                      ? {}
-                      : {
-                          transform: 'translateY(-4px) scale(1.02)',
-                          boxShadow: '0 20px 40px rgba(59, 130, 246, 0.2)',
-                        },
-                  })}
-                >
-                  <div
-                    className={css({
-                      fontSize: '4xl',
-                      mb: '2',
-                    })}
-                  >
-                    {config.icon}
-                  </div>
-                  <h3
-                    className={css({
-                      fontSize: 'xl',
-                      fontWeight: 'bold',
-                      color: 'gray.900',
-                      mb: '2',
-                    })}
-                  >
-                    {config.name}
-                  </h3>
-                  <p
-                    className={css({
-                      fontSize: 'sm',
-                      color: 'gray.600',
-                    })}
-                  >
-                    {config.description}
-                  </p>
-                </button>
-              )
-            })}
-
-            {/* Registry games */}
-            {getAllGames().map((gameDef) => {
-              const isAvailable = gameDef.manifest.available
-              return (
-                <button
-                  key={gameDef.manifest.name}
-                  onClick={() => handleGameSelect(gameDef.manifest.name)}
-                  disabled={!isAvailable}
-                  className={css({
-                    background: gameDef.manifest.gradient,
-                    border: '2px solid',
-                    borderColor: gameDef.manifest.borderColor,
-                    borderRadius: '2xl',
-                    padding: '6',
-                    cursor: !isAvailable ? 'not-allowed' : 'pointer',
-                    opacity: !isAvailable ? 0.5 : 1,
-                    transition: 'all 0.3s ease',
-                    _hover: !isAvailable
-                      ? {}
-                      : {
-                          transform: 'translateY(-4px) scale(1.02)',
-                          boxShadow: '0 20px 40px rgba(59, 130, 246, 0.2)',
-                        },
-                  })}
-                >
-                  <div
-                    className={css({
-                      fontSize: '4xl',
-                      mb: '2',
-                    })}
-                  >
-                    {gameDef.manifest.icon}
-                  </div>
-                  <h3
-                    className={css({
-                      fontSize: 'xl',
-                      fontWeight: 'bold',
-                      color: 'gray.900',
-                      mb: '2',
-                    })}
-                  >
-                    {gameDef.manifest.displayName}
-                  </h3>
-                  <p
-                    className={css({
-                      fontSize: 'sm',
-                      color: 'gray.600',
-                    })}
-                  >
-                    {gameDef.manifest.description}
-                  </p>
-                </button>
-              )
-            })}
-          </div>
-        </div>
-      </PageWithNav>
-    )
-  }
-
-  // Check if this is a registry game first
-  if (hasGame(roomData.gameName)) {
-    const gameDef = getGame(roomData.gameName)
-    if (!gameDef) {
-      return (
-        <PageWithNav
-          navTitle="Game Not Found"
-          navEmoji="⚠️"
-          emphasizePlayerSelection={true}
-          onExitSession={() => router.push('/arcade')}
-        >
-          <div
-            style={{
-              display: 'flex',
-              alignItems: 'center',
-              justifyContent: 'center',
-              height: '100vh',
-              fontSize: '18px',
-              color: '#666',
-            }}
-          >
-            Game "{roomData.gameName}" not found in registry
-          </div>
-        </PageWithNav>
-      )
-    }
-
-    // Render registry game dynamically
-    const { Provider, GameComponent } = gameDef
-    return (
-      <Provider>
-        <GameComponent />
-      </Provider>
-    )
-  }
-
-  // Render legacy games based on room's gameName
-  switch (roomData.gameName) {
-    // TODO: Add other legacy games (complement-race, etc.) once migrated
-    default:
-      return (
-        <PageWithNav
-          navTitle="Game Not Available"
-          navEmoji="⚠️"
-          emphasizePlayerSelection={true}
-          onExitSession={() => router.push('/arcade')}
-        >
-          <div
-            style={{
-              display: 'flex',
-              alignItems: 'center',
-              justifyContent: 'center',
-              height: '100vh',
-              fontSize: '18px',
-              color: '#666',
-            }}
-          >
-            Game "{roomData.gameName}" not yet supported
-          </div>
-        </PageWithNav>
-      )
-  }
-}
--- a/apps/web/src/app/join/[code]/page.tsx
+++ b/apps/web/src/app/join/[code]/page.tsx
@@ -231,7 +231,7 @@ export default function JoinRoomPage({ params }: { params: { code: string } }) {
          password: roomPassword,
        })
        // Navigate to the game
-        router.push('/arcade/room')
+        router.push('/arcade')
      } catch (err) {
        setError(err instanceof Error ? err.message : 'Failed to join room')
        setIsJoining(false)
@@ -261,7 +261,7 @@ export default function JoinRoomPage({ params }: { params: { code: string } }) {

        // If user is already in this exact room, just navigate to game
        if (roomData && roomData.id === room.id) {
-          router.push('/arcade/room')
+          router.push('/arcade')
          return
        }

@@ -313,7 +313,7 @@ export default function JoinRoomPage({ params }: { params: { code: string } }) {
  }

  const handleCancel = () => {
-    router.push('/arcade/room') // Stay in current room
+    router.push('/arcade') // Stay in current room
  }

  const handlePasswordSubmit = () => {
--- a/apps/web/src/app/page.tsx
+++ b/apps/web/src/app/page.tsx
@@ -2,184 +2,628 @@

 import Link from 'next/link'
 import { PageWithNav } from '@/components/PageWithNav'
+import { TutorialPlayer } from '@/components/tutorial/TutorialPlayer'
+import { getTutorialForEditor } from '@/utils/tutorialConverter'
 import { css } from '../../styled-system/css'
-import { container, hstack, stack } from '../../styled-system/patterns'
+import { container, grid, hstack, stack } from '../../styled-system/patterns'

 export default function HomePage() {
+  // Extract just the "Friends of 5" step (2+3=5) for homepage demo
+  const fullTutorial = getTutorialForEditor()
+  const friendsOf5Tutorial = {
+    ...fullTutorial,
+    id: 'friends-of-5-demo',
+    title: 'Friends of 5',
+    description: 'Learn the "Friends of 5" technique: adding 3 to make 5',
+    steps: fullTutorial.steps.filter((step) => step.id === 'complement-2'),
+  }
+
  return (
-    <PageWithNav navTitle="Soroban Flashcards" navEmoji="🧮">
-      <div
-        className={css({
-          minHeight: '100vh',
-          bg: 'gradient-to-br from-brand.50 to-brand.100',
-        })}
-      >
+    <PageWithNav navTitle="Soroban Learning Platform" navEmoji="🧮">
+      <div className={css({ bg: 'gray.900', minHeight: '100vh' })}>
        {/* Hero Section */}
-        <main className={container({ maxW: '6xl', px: '4' })}>
+        <div
+          className={css({
+            background:
+              'linear-gradient(135deg, rgba(17, 24, 39, 1) 0%, rgba(88, 28, 135, 0.3) 50%, rgba(17, 24, 39, 1) 100%)',
+            color: 'white',
+            py: { base: '12', md: '16' },
+            position: 'relative',
+            overflow: 'hidden',
+          })}
+        >
+          {/* Background pattern */}
          <div
-            className={stack({
-              gap: '12',
-              py: '16',
-              align: 'center',
-              textAlign: 'center',
+            className={css({
+              position: 'absolute',
+              inset: 0,
+              opacity: 0.1,
+              backgroundImage:
+                'radial-gradient(circle at 2px 2px, rgba(255, 255, 255, 0.15) 1px, transparent 0)',
+              backgroundSize: '40px 40px',
            })}
-          >
-            {/* Hero Content */}
-            <div className={stack({ gap: '6', maxW: '4xl' })}>
+          />
+
+          <div className={container({ maxW: '6xl', px: '4', position: 'relative' })}>
+            <div className={css({ textAlign: 'center', maxW: '5xl', mx: 'auto' })}>
+              {/* Main headline */}
              <h1
                className={css({
-                  fontSize: { base: '4xl', md: '6xl' },
+                  fontSize: { base: '3xl', md: '5xl', lg: '6xl' },
                  fontWeight: 'bold',
-                  color: 'gray.900',
+                  mb: '4',
                  lineHeight: 'tight',
+                  background: 'linear-gradient(135deg, #fbbf24 0%, #f59e0b 50%, #fbbf24 100%)',
+                  backgroundClip: 'text',
+                  color: 'transparent',
                })}
              >
-                Beautiful Soroban <span className={css({ color: 'brand.600' })}>Flashcards</span>
+                A structured path to soroban fluency
              </h1>

+              {/* Subtitle */}
              <p
                className={css({
                  fontSize: { base: 'lg', md: 'xl' },
-                  color: 'gray.600',
-                  maxW: '2xl',
+                  color: 'gray.300',
+                  mb: '6',
+                  maxW: '3xl',
                  mx: 'auto',
+                  lineHeight: '1.6',
                })}
              >
-                Create stunning, educational flashcards with authentic Japanese abacus
-                representations. Perfect for teachers, students, and mental math enthusiasts.
+                Designed for self-directed learning. Start where you are, practice the skills you
+                need, play games that reinforce concepts.
              </p>

-              <div className={hstack({ gap: '4', justify: 'center', mt: '8' })}>
-                <Link
-                  href="/create"
-                  className={css({
-                    px: '8',
-                    py: '4',
-                    bg: 'brand.600',
-                    color: 'white',
-                    fontSize: 'lg',
-                    fontWeight: 'semibold',
-                    rounded: 'xl',
-                    shadow: 'card',
-                    transition: 'all',
-                    _hover: {
-                      bg: 'brand.700',
-                      transform: 'translateY(-2px)',
-                      shadow: 'modal',
-                    },
-                  })}
-                >
-                  ✨ Start Creating →
-                </Link>
+              {/* Dev status badge */}
+              <div
+                className={css({
+                  display: 'inline-block',
+                  px: '4',
+                  py: '2',
+                  bg: 'rgba(139, 92, 246, 0.15)',
+                  border: '1px solid rgba(139, 92, 246, 0.3)',
+                  borderRadius: 'full',
+                  fontSize: 'sm',
+                  color: 'purple.300',
+                  mb: '8',
+                })}
+              >
+                🏗️ Curriculum system in active development
+              </div>

+              {/* Visual learning journey */}
+              <div
+                className={css({
+                  display: 'flex',
+                  justifyContent: 'center',
+                  alignItems: 'center',
+                  gap: '2',
+                  mb: '8',
+                  flexWrap: 'wrap',
+                })}
+              >
+                {[
+                  { icon: '📖', label: 'Learn' },
+                  { icon: '→', label: '', isArrow: true },
+                  { icon: '✏️', label: 'Practice' },
+                  { icon: '→', label: '', isArrow: true },
+                  { icon: '🎮', label: 'Play' },
+                  { icon: '→', label: '', isArrow: true },
+                  { icon: '🎯', label: 'Master' },
+                ].map((step, i) => (
+                  <div
+                    key={i}
+                    className={css({
+                      display: 'flex',
+                      flexDirection: 'column',
+                      alignItems: 'center',
+                      gap: '1',
+                      opacity: step.isArrow ? 0.5 : 1,
+                    })}
+                  >
+                    <div
+                      className={css({
+                        fontSize: step.isArrow ? 'xl' : '2xl',
+                        color: step.isArrow ? 'gray.500' : 'yellow.400',
+                      })}
+                    >
+                      {step.icon}
+                    </div>
+                    {step.label && (
+                      <div className={css({ fontSize: 'xs', color: 'gray.400' })}>{step.label}</div>
+                    )}
+                  </div>
+                ))}
+              </div>
+
+              {/* Primary CTAs */}
+              <div className={hstack({ gap: '4', justify: 'center', flexWrap: 'wrap' })}>
                <Link
                  href="/guide"
                  className={css({
                    px: '8',
                    py: '4',
-                    bg: 'white',
-                    color: 'brand.700',
+                    bg: 'linear-gradient(135deg, #fbbf24, #f59e0b)',
+                    color: 'gray.900',
+                    fontWeight: 'bold',
                    fontSize: 'lg',
-                    fontWeight: 'semibold',
                    rounded: 'xl',
-                    shadow: 'card',
-                    border: '2px solid',
-                    borderColor: 'brand.200',
-                    transition: 'all',
+                    shadow: '0 10px 40px rgba(251, 191, 36, 0.3)',
                    _hover: {
-                      borderColor: 'brand.400',
                      transform: 'translateY(-2px)',
+                      shadow: '0 20px 50px rgba(251, 191, 36, 0.4)',
                    },
+                    transition: 'all 0.3s ease',
                  })}
                >
-                  📚 Learn Soroban
+                  📚 Start Learning
+                </Link>
+                <Link
+                  href="/games"
+                  className={css({
+                    px: '8',
+                    py: '4',
+                    bg: 'rgba(139, 92, 246, 0.2)',
+                    color: 'white',
+                    fontWeight: 'bold',
+                    fontSize: 'lg',
+                    rounded: 'xl',
+                    border: '2px solid',
+                    borderColor: 'purple.500',
+                    _hover: {
+                      bg: 'rgba(139, 92, 246, 0.3)',
+                      transform: 'translateY(-2px)',
+                    },
+                    transition: 'all 0.3s ease',
+                  })}
+                >
+                  🎮 Practice Through Games
                </Link>
              </div>
            </div>
+          </div>
+        </div>

-            {/* Features Grid */}
+        {/* Main content container */}
+        <div className={container({ maxW: '7xl', px: '4', py: '12' })}>
+          {/* Learn by Doing Section - with inline tutorial demo */}
+          <section className={stack({ gap: '8', mb: '16' })}>
+            <div className={css({ textAlign: 'center' })}>
+              <h2
+                className={css({
+                  fontSize: { base: '2xl', md: '3xl' },
+                  fontWeight: 'bold',
+                  color: 'white',
+                  mb: '2',
+                })}
+              >
+                Learn by Doing
+              </h2>
+              <p className={css({ color: 'gray.400', fontSize: 'md', maxW: '2xl', mx: 'auto' })}>
+                Interactive tutorials teach you step-by-step. Try this example right now:
+              </p>
+            </div>
+
+            {/* Live demo and learning objectives */}
            <div
              className={css({
-                display: 'grid',
-                gridTemplateColumns: { base: '1', md: '3' },
-                gap: '8',
-                mt: '16',
-                w: 'full',
+                bg: 'rgba(0, 0, 0, 0.4)',
+                rounded: 'xl',
+                p: '8',
+                border: '1px solid',
+                borderColor: 'gray.700',
+                shadow: 'lg',
+                maxW: '900px',
+                mx: 'auto',
              })}
            >
-              <FeatureCard
-                icon="🎨"
-                title="Beautiful Design"
-                description="Vector graphics, color schemes, authentic bead positioning"
+              <TutorialPlayer
+                tutorial={friendsOf5Tutorial}
+                isDebugMode={false}
+                showDebugPanel={false}
+                hideNavigation={true}
+                abacusColumns={2}
+                theme="dark"
              />
-              <FeatureCard
-                icon="⚡"
-                title="Instant Generation"
-                description="Create PDFs, interactive HTML, PNGs, and SVGs in seconds"
+
+              {/* What you'll learn - below tutorial */}
+              <div
+                className={css({
+                  mt: '8',
+                  pt: '6',
+                  borderTop: '1px solid',
+                  borderColor: 'gray.700',
+                })}
+              >
+                <h3
+                  className={css({
+                    fontSize: 'xl',
+                    fontWeight: 'bold',
+                    color: 'white',
+                    mb: '4',
+                    textAlign: 'center',
+                  })}
+                >
+                  What You'll Learn
+                </h3>
+                <div className={grid({ columns: { base: 1, sm: 2 }, gap: '3' })}>
+                  {[
+                    'Read and set numbers on an abacus',
+                    'Add and subtract with "friends" techniques',
+                    'Multiply and divide fluently',
+                    'Calculate mentally without the abacus',
+                  ].map((skill, i) => (
+                    <div key={i} className={hstack({ gap: '3' })}>
+                      <span className={css({ color: 'yellow.400', fontSize: 'lg' })}>✓</span>
+                      <span className={css({ color: 'gray.300', fontSize: 'sm' })}>{skill}</span>
+                    </div>
+                  ))}
+                </div>
+              </div>
+            </div>
+          </section>
+
+          {/* Current Offerings Section */}
+          <section className={stack({ gap: '6', mb: '16' })}>
+            <div className={css({ textAlign: 'center' })}>
+              <h2
+                className={css({
+                  fontSize: { base: '2xl', md: '3xl' },
+                  fontWeight: 'bold',
+                  color: 'white',
+                  mb: '2',
+                })}
+              >
+                Available Now
+              </h2>
+              <p className={css({ color: 'gray.400', fontSize: 'md' })}>
+                Foundation tutorials and reinforcement games ready to use
+              </p>
+            </div>
+
+            <div className={grid({ columns: { base: 1, sm: 2, lg: 4 }, gap: '5' })}>
+              <GameCard
+                icon="🧠"
+                title="Memory Lightning"
+                description="Memorize soroban numbers"
+                players="1-8 players"
+                tags={['Memory', 'Pattern Recognition']}
+                gradient="linear-gradient(135deg, #667eea 0%, #764ba2 100%)"
+                href="/games"
              />
-              <FeatureCard
-                icon="🎯"
-                title="Educational Focus"
-                description="Perfect for teachers, students, and soroban enthusiasts"
+              <GameCard
+                icon="⚔️"
+                title="Matching Pairs"
+                description="Match complement numbers"
+                players="1-4 players"
+                tags={['Friends of 5', 'Friends of 10']}
+                gradient="linear-gradient(135deg, #f093fb 0%, #f5576c 100%)"
+                href="/games"
+              />
+              <GameCard
+                icon="🏁"
+                title="Complement Race"
+                description="Race against time"
+                players="1-4 players"
+                tags={['Speed', 'Practice', 'Survival']}
+                gradient="linear-gradient(135deg, #4facfe 0%, #00f2fe 100%)"
+                href="/games"
+              />
+              <GameCard
+                icon="🔢"
+                title="Card Sorting"
+                description="Arrange numbers visually"
+                players="Solo challenge"
+                tags={['Visual Literacy', 'Ordering']}
+                gradient="linear-gradient(135deg, #43e97b 0%, #38f9d7 100%)"
+                href="/games"
              />
            </div>
-          </div>
-        </main>
+          </section>
+
+          {/* For Kids & Families Section */}
+          <section className={stack({ gap: '6', mb: '16' })}>
+            <div className={css({ textAlign: 'center' })}>
+              <h2
+                className={css({
+                  fontSize: { base: '2xl', md: '3xl' },
+                  fontWeight: 'bold',
+                  color: 'white',
+                  mb: '2',
+                })}
+              >
+                For Kids & Families
+              </h2>
+              <p className={css({ color: 'gray.400', fontSize: 'md', maxW: '2xl', mx: 'auto' })}>
+                Simple enough for kids to start on their own, structured enough for parents to trust
+              </p>
+            </div>
+
+            <div className={grid({ columns: { base: 1, lg: 2 }, gap: '8' })}>
+              <FeaturePanel
+                icon="🧒"
+                title="Self-Directed for Children"
+                features={[
+                  'Big, obvious buttons and clear instructions',
+                  'Progress at your own pace',
+                  'Works with or without a physical abacus',
+                ]}
+                accentColor="purple"
+              />
+              <FeaturePanel
+                icon="👨‍👩‍👧"
+                title="Trusted by Parents"
+                features={[
+                  'Structured curriculum following Japanese methods',
+                  'Traditional kyu/dan progression levels',
+                  'Track progress and celebrate achievements',
+                ]}
+                accentColor="blue"
+              />
+            </div>
+          </section>
+
+          {/* Progression Visualization */}
+          <section className={stack({ gap: '6', mb: '16' })}>
+            <div className={css({ textAlign: 'center' })}>
+              <h2
+                className={css({
+                  fontSize: { base: '2xl', md: '3xl' },
+                  fontWeight: 'bold',
+                  color: 'white',
+                  mb: '2',
+                })}
+              >
+                Your Journey
+              </h2>
+              <p className={css({ color: 'gray.400', fontSize: 'md' })}>
+                Progress from beginner to master
+              </p>
+            </div>
+
+            <div
+              className={css({
+                bg: 'rgba(0, 0, 0, 0.4)',
+                border: '1px solid',
+                borderColor: 'gray.700',
+                rounded: 'xl',
+                p: '8',
+              })}
+            >
+              <div
+                className={css({
+                  display: 'flex',
+                  justifyContent: 'space-between',
+                  alignItems: 'center',
+                  gap: '4',
+                  flexWrap: 'wrap',
+                })}
+              >
+                {[
+                  { level: '10 Kyu', label: 'Beginner', color: 'green.400' },
+                  { level: '5 Kyu', label: 'Intermediate', color: 'blue.400' },
+                  { level: '1 Kyu', label: 'Advanced', color: 'purple.400' },
+                  { level: 'Dan', label: 'Master', color: 'yellow.400' },
+                ].map((stage, i) => (
+                  <div key={i} className={stack({ gap: '2', textAlign: 'center', flex: '1' })}>
+                    <div
+                      className={css({
+                        fontSize: 'xl',
+                        fontWeight: 'bold',
+                        color: stage.color,
+                      })}
+                    >
+                      {stage.level}
+                    </div>
+                    <div className={css({ fontSize: 'sm', color: 'gray.400' })}>{stage.label}</div>
+                    {i < 3 && (
+                      <div
+                        className={css({
+                          display: { base: 'none', md: 'block' },
+                          position: 'absolute',
+                          right: '-50%',
+                          fontSize: 'xl',
+                          color: 'gray.600',
+                        })}
+                      >
+                        →
+                      </div>
+                    )}
+                  </div>
+                ))}
+              </div>
+              <div
+                className={css({
+                  mt: '6',
+                  textAlign: 'center',
+                  fontSize: 'sm',
+                  color: 'gray.500',
+                  fontStyle: 'italic',
+                })}
+              >
+                You'll progress through all these levels eventually ↑
+              </div>
+            </div>
+          </section>
+
+          {/* Additional Tools Section */}
+          <section className={stack({ gap: '6' })}>
+            <div className={css({ textAlign: 'center' })}>
+              <h2
+                className={css({
+                  fontSize: { base: '2xl', md: '3xl' },
+                  fontWeight: 'bold',
+                  color: 'white',
+                  mb: '2',
+                })}
+              >
+                Additional Tools
+              </h2>
+            </div>
+
+            <div className={grid({ columns: { base: 1, lg: 2 }, gap: '8' })}>
+              <FeaturePanel
+                icon="🎨"
+                title="Flashcard Creator"
+                features={[
+                  'Multiple formats: PDF, PNG, SVG, HTML',
+                  'Custom bead shapes, colors, and layouts',
+                  'All paper sizes: A3, A4, A5, US Letter',
+                ]}
+                accentColor="blue"
+                ctaText="Create Flashcards →"
+                ctaHref="/create"
+              />
+              <FeaturePanel
+                icon="🧮"
+                title="Interactive Abacus"
+                features={[
+                  'Practice anytime in your browser',
+                  'Multiple color schemes and bead styles',
+                  'Sound effects and animations',
+                ]}
+                accentColor="purple"
+                ctaText="Try the Abacus →"
+                ctaHref="/guide"
+              />
+            </div>
+          </section>
+        </div>
      </div>
    </PageWithNav>
  )
 }

-function FeatureCard({
+function GameCard({
  icon,
  title,
  description,
+  players,
+  tags,
+  gradient,
+  href,
 }: {
  icon: string
  title: string
  description: string
+  players: string
+  tags: string[]
+  gradient: string
+  href: string
 }) {
+  return (
+    <Link href={href}>
+      <div
+        className={css({
+          background: gradient,
+          rounded: 'xl',
+          p: '6',
+          shadow: 'lg',
+          transition: 'all 0.3s ease',
+          cursor: 'pointer',
+          _hover: {
+            transform: 'translateY(-6px) scale(1.02)',
+            shadow: '0 25px 50px rgba(0, 0, 0, 0.3)',
+          },
+        })}
+      >
+        <div className={css({ fontSize: '3xl', mb: '3' })}>{icon}</div>
+        <h3 className={css({ fontSize: 'lg', fontWeight: 'bold', color: 'white', mb: '2' })}>
+          {title}
+        </h3>
+        <p className={css({ fontSize: 'sm', color: 'rgba(255, 255, 255, 0.9)', mb: '2' })}>
+          {description}
+        </p>
+        <p className={css({ fontSize: 'xs', color: 'rgba(255, 255, 255, 0.7)', mb: '3' })}>
+          {players}
+        </p>
+        <div className={hstack({ gap: '2', flexWrap: 'wrap' })}>
+          {tags.map((tag) => (
+            <span
+              key={tag}
+              className={css({
+                fontSize: 'xs',
+                px: '2',
+                py: '1',
+                bg: 'rgba(255, 255, 255, 0.2)',
+                color: 'white',
+                rounded: 'full',
+                fontWeight: 'semibold',
+              })}
+            >
+              {tag}
+            </span>
+          ))}
+        </div>
+      </div>
+    </Link>
+  )
+}
+
+function FeaturePanel({
+  icon,
+  title,
+  features,
+  accentColor,
+  ctaText,
+  ctaHref,
+}: {
+  icon: string
+  title: string
+  features: string[]
+  accentColor: 'purple' | 'blue'
+  ctaText?: string
+  ctaHref?: string
+}) {
+  const borderColor = accentColor === 'purple' ? 'purple.500/30' : 'blue.500/30'
+  const bgColor = accentColor === 'purple' ? 'purple.500/10' : 'blue.500/10'
+  const hoverBg = accentColor === 'purple' ? 'purple.500/20' : 'blue.500/20'
+
  return (
    <div
      className={css({
+        bg: 'rgba(0, 0, 0, 0.4)',
+        rounded: 'xl',
        p: '8',
-        bg: 'white',
-        rounded: '2xl',
-        shadow: 'card',
-        textAlign: 'center',
-        transition: 'all',
-        _hover: {
-          transform: 'translateY(-4px)',
-          shadow: 'modal',
-        },
+        border: '2px solid',
+        borderColor,
      })}
    >
-      <div
-        className={css({
-          fontSize: '4xl',
-          mb: '4',
-        })}
-      >
-        {icon}
+      <div className={hstack({ gap: '3', mb: '4' })}>
+        <span className={css({ fontSize: '3xl' })}>{icon}</span>
+        <h2 className={css({ fontSize: '2xl', fontWeight: 'bold', color: 'white' })}>{title}</h2>
      </div>
-      <h3
-        className={css({
-          fontSize: 'xl',
-          fontWeight: 'bold',
-          color: 'gray.900',
-          mb: '3',
-        })}
-      >
-        {title}
-      </h3>
-      <p
-        className={css({
-          color: 'gray.600',
-          lineHeight: 'relaxed',
-        })}
-      >
-        {description}
-      </p>
+      <div className={stack({ gap: '3', mb: ctaText ? '6' : '0' })}>
+        {features.map((feature, i) => (
+          <div key={i} className={hstack({ gap: '3' })}>
+            <span className={css({ color: 'yellow.400', fontSize: 'lg' })}>✓</span>
+            <span className={css({ color: 'gray.300', fontSize: 'sm' })}>{feature}</span>
+          </div>
+        ))}
+      </div>
+      {ctaText && ctaHref && (
+        <Link
+          href={ctaHref}
+          className={css({
+            display: 'block',
+            textAlign: 'center',
+            py: '3',
+            px: '6',
+            bg: bgColor,
+            color: 'white',
+            fontWeight: 'bold',
+            rounded: 'lg',
+            border: '2px solid',
+            borderColor,
+            _hover: { bg: hoverBg },
+            transition: 'all 0.2s ease',
+          })}
+        >
+          {ctaText}
+        </Link>
+      )}
    </div>
  )
 }
--- a/apps/web/src/arcade-games/card-sorting/Provider.tsx
+++ b/apps/web/src/arcade-games/card-sorting/Provider.tsx
@@ -1,13 +1,6 @@
 'use client'

-import {
-  type ReactNode,
-  useCallback,
-  useMemo,
-  createContext,
-  useContext,
-  useState,
-} from 'react'
+import { type ReactNode, useCallback, useMemo, createContext, useContext, useState } from 'react'
 import { useArcadeSession } from '@/hooks/useArcadeSession'
 import { useRoomData, useUpdateGameConfig } from '@/hooks/useRoomData'
 import { useViewerId } from '@/hooks/useViewerId'
@@ -40,6 +33,9 @@ interface CardSortingContextValue {
  // UI state
  selectedCardId: string | null
  selectCard: (cardId: string | null) => void
+  // Spectator mode
+  localPlayerId: string | undefined
+  isSpectating: boolean
 }

 // Create context
@@ -553,6 +549,9 @@ export function CardSortingProvider({ children }: { children: ReactNode }) {
    // UI state
    selectedCardId,
    selectCard: setSelectedCardId,
+    // Spectator mode
+    localPlayerId,
+    isSpectating: !localPlayerId,
  }

  return <CardSortingContext.Provider value={contextValue}>{children}</CardSortingContext.Provider>
--- a/apps/web/src/arcade-games/card-sorting/components/GameComponent.tsx
+++ b/apps/web/src/arcade-games/card-sorting/components/GameComponent.tsx
@@ -13,7 +13,7 @@ import { ResultsPhase } from './ResultsPhase'

 export function GameComponent() {
  const router = useRouter()
-  const { state, exitSession, startGame, goToSetup } = useCardSorting()
+  const { state, exitSession, startGame, goToSetup, isSpectating } = useCardSorting()
  const { setFullscreenElement } = useFullscreen()
  const gameRef = useRef<HTMLDivElement>(null)

@@ -57,6 +57,34 @@ export function GameComponent() {
            overflow: 'auto',
          })}
        >
+          {/* Spectator Mode Banner */}
+          {isSpectating && state.gamePhase !== 'setup' && (
+            <div
+              className={css({
+                width: '100%',
+                maxWidth: '1200px',
+                background: 'linear-gradient(135deg, #fef3c7, #fde68a)',
+                borderRadius: { base: '8px', md: '12px' },
+                padding: { base: '12px', md: '16px' },
+                marginBottom: { base: '12px', md: '16px' },
+                boxShadow: '0 4px 12px rgba(0,0,0,0.1)',
+                display: 'flex',
+                alignItems: 'center',
+                justifyContent: 'center',
+                gap: '8px',
+                fontSize: { base: '14px', sm: '16px', md: '18px' },
+                fontWeight: '600',
+                color: '#92400e',
+                textAlign: 'center',
+              })}
+            >
+              <span role="img" aria-label="watching">
+                👀
+              </span>
+              <span>Spectating {state.playerMetadata?.name || 'player'}'s game</span>
+            </div>
+          )}
+
          <main
            className={css({
              width: '100%',
--- a/apps/web/src/arcade-games/card-sorting/components/PlayingPhase.tsx
+++ b/apps/web/src/arcade-games/card-sorting/components/PlayingPhase.tsx
@@ -18,6 +18,7 @@ export function PlayingPhase() {
    canCheckSolution,
    placedCount,
    elapsedTime,
+    isSpectating,
  } = useCardSorting()

  // Status message (mimics Python updateSortingStatus)
@@ -64,6 +65,7 @@ export function PlayingPhase() {
  }

  const handleCardClick = (cardId: string) => {
+    if (isSpectating) return // Spectators cannot interact
    if (selectedCardId === cardId) {
      selectCard(null) // Deselect
    } else {
@@ -72,6 +74,7 @@ export function PlayingPhase() {
  }

  const handleSlotClick = (position: number) => {
+    if (isSpectating) return // Spectators cannot interact
    if (!selectedCardId) {
      // No card selected - if slot has a card, move it back and auto-select
      if (state.placedCards[position]) {
@@ -89,6 +92,7 @@ export function PlayingPhase() {
  }

  const handleInsertClick = (insertPosition: number) => {
+    if (isSpectating) return // Spectators cannot interact
    if (!selectedCardId) {
      setStatusMessage('Please select a card first, then click where to insert it.')
      return
@@ -181,17 +185,19 @@ export function PlayingPhase() {
            <button
              type="button"
              onClick={revealNumbers}
+              disabled={isSpectating}
              className={css({
                padding: '0.5rem 1rem',
                borderRadius: '0.375rem',
-                background: 'orange.500',
+                background: isSpectating ? 'gray.300' : 'orange.500',
                color: 'white',
                fontSize: 'sm',
                fontWeight: '600',
                border: 'none',
-                cursor: 'pointer',
+                cursor: isSpectating ? 'not-allowed' : 'pointer',
+                opacity: isSpectating ? 0.5 : 1,
                _hover: {
-                  background: 'orange.600',
+                  background: isSpectating ? 'gray.300' : 'orange.600',
                },
              })}
            >
@@ -201,19 +207,19 @@ export function PlayingPhase() {
          <button
            type="button"
            onClick={checkSolution}
-            disabled={!canCheckSolution}
+            disabled={!canCheckSolution || isSpectating}
            className={css({
              padding: '0.5rem 1rem',
              borderRadius: '0.375rem',
-              background: canCheckSolution ? 'teal.600' : 'gray.300',
+              background: canCheckSolution && !isSpectating ? 'teal.600' : 'gray.300',
              color: 'white',
              fontSize: 'sm',
              fontWeight: '600',
              border: 'none',
-              cursor: canCheckSolution ? 'pointer' : 'not-allowed',
-              opacity: canCheckSolution ? 1 : 0.6,
+              cursor: canCheckSolution && !isSpectating ? 'pointer' : 'not-allowed',
+              opacity: canCheckSolution && !isSpectating ? 1 : 0.5,
              _hover: {
-                background: canCheckSolution ? 'teal.700' : 'gray.300',
+                background: canCheckSolution && !isSpectating ? 'teal.700' : 'gray.300',
              },
            })}
          >
@@ -222,17 +228,19 @@ export function PlayingPhase() {
          <button
            type="button"
            onClick={goToSetup}
+            disabled={isSpectating}
            className={css({
              padding: '0.5rem 1rem',
              borderRadius: '0.375rem',
-              background: 'gray.600',
+              background: isSpectating ? 'gray.400' : 'gray.600',
              color: 'white',
              fontSize: 'sm',
              fontWeight: '600',
              border: 'none',
-              cursor: 'pointer',
+              cursor: isSpectating ? 'not-allowed' : 'pointer',
+              opacity: isSpectating ? 0.5 : 1,
              _hover: {
-                background: 'gray.700',
+                background: isSpectating ? 'gray.400' : 'gray.700',
              },
            })}
          >
@@ -264,13 +272,15 @@ export function PlayingPhase() {
          </h3>
          <div
            className={css({
-              display: 'grid',
-              gridTemplateColumns: {
-                base: '1',
-                sm: '2',
-                md: '3',
-              },
-              gap: '0.75rem',
+              display: 'flex',
+              flexWrap: 'wrap',
+              gap: '10px',
+              justifyContent: 'center',
+              padding: '15px',
+              background: 'rgba(255,255,255,0.5)',
+              borderRadius: '8px',
+              minHeight: '120px',
+              border: '2px dashed #2c5f76',
            })}
          >
            {state.availableCards.map((card) => (
@@ -278,39 +288,68 @@ export function PlayingPhase() {
                key={card.id}
                onClick={() => handleCardClick(card.id)}
                className={css({
-                  padding: '0.5rem',
+                  width: '140px',
+                  height: '140px',
+                  padding: '8px',
                  border: '2px solid',
-                  borderColor: selectedCardId === card.id ? 'blue.500' : 'gray.300',
-                  borderRadius: '0.5rem',
-                  background: selectedCardId === card.id ? 'blue.50' : 'white',
-                  cursor: 'pointer',
-                  transition: 'all 0.2s',
-                  transform: selectedCardId === card.id ? 'scale(1.05)' : 'scale(1)',
-                  _hover: {
-                    transform: 'scale(1.05)',
-                    borderColor: 'blue.500',
-                    boxShadow: '0 4px 12px rgba(0,0,0,0.15)',
-                  },
+                  borderColor: selectedCardId === card.id ? '#1976d2' : 'transparent',
+                  borderRadius: '8px',
+                  background: selectedCardId === card.id ? '#e3f2fd' : 'white',
+                  cursor: isSpectating ? 'not-allowed' : 'pointer',
+                  opacity: isSpectating ? 0.5 : 1,
+                  transition: 'all 0.3s cubic-bezier(0.4, 0, 0.2, 1)',
+                  position: 'relative',
+                  userSelect: 'none',
+                  display: 'flex',
+                  flexDirection: 'column',
+                  alignItems: 'center',
+                  justifyContent: 'center',
+                  boxShadow: '0 2px 6px rgba(0,0,0,0.1)',
+                  _hover: isSpectating
+                    ? {}
+                    : {
+                        transform: 'translateY(-5px)',
+                        boxShadow: '0 8px 16px rgba(0,0,0,0.2)',
+                        borderColor: '#2c5f76',
+                      },
                })}
+                style={
+                  selectedCardId === card.id
+                    ? {
+                        transform: 'scale(1.1)',
+                        boxShadow: '0 6px 20px rgba(25, 118, 210, 0.3)',
+                      }
+                    : undefined
+                }
              >
                <div
                  dangerouslySetInnerHTML={{ __html: card.svgContent }}
                  className={css({
                    width: '100%',
+                    height: '100%',
+                    display: 'flex',
+                    alignItems: 'center',
+                    justifyContent: 'center',
+                    overflow: 'hidden',
                    '& svg': {
                      width: '100%',
-                      height: 'auto',
+                      height: '100%',
+                      display: 'block',
                    },
                  })}
                />
                {state.numbersRevealed && (
                  <div
                    className={css({
-                      textAlign: 'center',
-                      marginTop: '0.5rem',
-                      fontSize: 'lg',
+                      position: 'absolute',
+                      top: '5px',
+                      right: '5px',
+                      background: '#ffc107',
+                      color: '#333',
+                      borderRadius: '4px',
+                      padding: '2px 8px',
+                      fontSize: '14px',
                      fontWeight: 'bold',
-                      color: 'gray.700',
                    })}
                  >
                    {card.number}
@@ -336,35 +375,43 @@ export function PlayingPhase() {
          <div
            className={css({
              display: 'flex',
-              flexDirection: 'column',
-              gap: '0.25rem',
+              flexWrap: 'wrap',
+              gap: '8px',
+              justifyContent: 'center',
+              alignItems: 'center',
+              padding: '15px',
+              background: 'rgba(255,255,255,0.7)',
+              borderRadius: '8px',
+              border: '2px dashed #2c5f76',
            })}
          >
            {/* Insert button before first position */}
            <button
              type="button"
              onClick={() => handleInsertClick(0)}
-              disabled={!selectedCardId}
+              disabled={!selectedCardId || isSpectating}
              className={css({
                width: '32px',
                height: '50px',
-                background: selectedCardId ? '#1976d2' : '#2c5f76',
+                background: selectedCardId && !isSpectating ? '#1976d2' : '#2c5f76',
                color: 'white',
                border: 'none',
                borderRadius: '20px',
                fontSize: '24px',
                fontWeight: 'bold',
-                cursor: selectedCardId ? 'pointer' : 'default',
-                opacity: selectedCardId ? 1 : 0.3,
+                cursor: selectedCardId && !isSpectating ? 'pointer' : 'not-allowed',
+                opacity: selectedCardId && !isSpectating ? 1 : 0.3,
                transition: 'all 0.2s',
                display: 'flex',
                alignItems: 'center',
                justifyContent: 'center',
-                _hover: {
-                  opacity: 1,
-                  background: '#1976d2',
-                  transform: selectedCardId ? 'scale(1.1)' : 'none',
-                },
+                _hover: isSpectating
+                  ? {}
+                  : {
+                      opacity: 1,
+                      background: '#1976d2',
+                      transform: selectedCardId ? 'scale(1.1)' : 'none',
+                    },
              })}
            >
              +
@@ -376,17 +423,19 @@ export function PlayingPhase() {
              const isEmpty = card === null

              return (
-                <div key={index}>
+                <>
                  {/* Position slot */}
                  <div
+                    key={`slot-${index}`}
                    onClick={() => handleSlotClick(index)}
                    className={css({
-                      width: '90px',
-                      height: '110px',
+                      width: '140px',
+                      height: '160px',
                      padding: '0.5rem',
                      borderRadius: '8px',
                      border: '2px solid',
-                      cursor: 'pointer',
+                      cursor: isSpectating ? 'not-allowed' : 'pointer',
+                      opacity: isSpectating ? 0.5 : 1,
                      transition: 'all 0.2s',
                      display: 'flex',
                      flexDirection: 'column',
@@ -394,20 +443,23 @@ export function PlayingPhase() {
                      justifyContent: 'center',
                      gap: '0.25rem',
                      position: 'relative',
-                      _hover: {
-                        transform: selectedCardId && isEmpty ? 'scale(1.05)' : 'none',
-                        boxShadow:
-                          selectedCardId && isEmpty ? '0 4px 12px rgba(0,0,0,0.15)' : 'none',
-                      },
+                      _hover: isSpectating
+                        ? {}
+                        : {
+                            transform: selectedCardId && isEmpty ? 'scale(1.05)' : 'none',
+                            boxShadow:
+                              selectedCardId && isEmpty ? '0 4px 12px rgba(0,0,0,0.15)' : 'none',
+                          },
                    })}
                    style={
                      isEmpty
                        ? {
                            ...gradientStyle,
                            // Active state: add slight glow when card is selected
-                            boxShadow: selectedCardId
-                              ? '0 0 0 2px #1976d2, 0 2px 8px rgba(25, 118, 210, 0.3)'
-                              : 'none',
+                            boxShadow:
+                              selectedCardId && !isSpectating
+                                ? '0 0 0 2px #1976d2, 0 2px 8px rgba(25, 118, 210, 0.3)'
+                                : 'none',
                          }
                        : {
                            background: '#fff',
@@ -423,10 +475,16 @@ export function PlayingPhase() {
                            __html: card.svgContent,
                          }}
                          className={css({
-                            width: '70px',
+                            flex: 1,
+                            width: '100%',
+                            display: 'flex',
+                            alignItems: 'center',
+                            justifyContent: 'center',
+                            overflow: 'hidden',
                            '& svg': {
                              width: '100%',
-                              height: 'auto',
+                              height: '100%',
+                              display: 'block',
                            },
                          })}
                        />
@@ -457,35 +515,37 @@ export function PlayingPhase() {

                  {/* Insert button after this position */}
                  <button
+                    key={`insert-${index + 1}`}
                    type="button"
                    onClick={() => handleInsertClick(index + 1)}
-                    disabled={!selectedCardId}
+                    disabled={!selectedCardId || isSpectating}
                    className={css({
                      width: '32px',
                      height: '50px',
-                      background: selectedCardId ? '#1976d2' : '#2c5f76',
+                      background: selectedCardId && !isSpectating ? '#1976d2' : '#2c5f76',
                      color: 'white',
                      border: 'none',
                      borderRadius: '20px',
                      fontSize: '24px',
                      fontWeight: 'bold',
-                      cursor: selectedCardId ? 'pointer' : 'default',
-                      opacity: selectedCardId ? 1 : 0.3,
+                      cursor: selectedCardId && !isSpectating ? 'pointer' : 'not-allowed',
+                      opacity: selectedCardId && !isSpectating ? 1 : 0.3,
                      transition: 'all 0.2s',
-                      marginTop: '0.25rem',
                      display: 'flex',
                      alignItems: 'center',
                      justifyContent: 'center',
-                      _hover: {
-                        opacity: 1,
-                        background: '#1976d2',
-                        transform: selectedCardId ? 'scale(1.1)' : 'none',
-                      },
+                      _hover: isSpectating
+                        ? {}
+                        : {
+                            opacity: 1,
+                            background: '#1976d2',
+                            transform: selectedCardId ? 'scale(1.1)' : 'none',
+                          },
                    })}
                  >
                    +
                  </button>
-                </div>
+                </>
              )
            })}
          </div>
--- a/apps/web/src/arcade-games/card-sorting/index.ts
+++ b/apps/web/src/arcade-games/card-sorting/index.ts
@@ -5,7 +5,7 @@
 * in ascending order using only visual patterns (no numbers shown).
 */

-import { defineGame } from '@/lib/arcade/game-sdk'
+import { defineGame, getGameTheme } from '@/lib/arcade/game-sdk'
 import type { GameManifest } from '@/lib/arcade/game-sdk'
 import { GameComponent } from './components/GameComponent'
 import { CardSortingProvider } from './Provider'
@@ -24,9 +24,7 @@ const manifest: GameManifest = {
  maxPlayers: 1, // Single player only
  difficulty: 'Intermediate',
  chips: ['🧠 Pattern Recognition', '🎯 Solo Challenge', '📊 Smart Scoring'],
-  color: 'teal',
-  gradient: 'linear-gradient(135deg, #99f6e4, #5eead4)',
-  borderColor: 'teal.200',
+  ...getGameTheme('teal'),
  available: true,
 }

--- a/apps/web/src/arcade-games/complement-race/index.tsx
+++ b/apps/web/src/arcade-games/complement-race/index.tsx
@@ -3,7 +3,7 @@
 * Complete integration into the arcade system with multiplayer support
 */

-import { defineGame } from '@/lib/arcade/game-sdk'
+import { defineGame, getGameTheme } from '@/lib/arcade/game-sdk'
 import type { GameManifest } from '@/lib/arcade/game-sdk'
 import { complementRaceValidator } from './Validator'
 import { ComplementRaceProvider } from './Provider'
@@ -20,9 +20,7 @@ const manifest: GameManifest = {
  maxPlayers: 4,
  icon: '🏁',
  chips: ['👥 1-4 Players', '🚂 Sprint Mode', '🤖 AI Opponents', '🔥 Speed Challenge'],
-  color: 'blue',
-  gradient: 'linear-gradient(135deg, #dbeafe, #bfdbfe)',
-  borderColor: 'blue.200',
+  ...getGameTheme('blue'),
  difficulty: 'Intermediate',
  available: true,
 }
--- a/apps/web/src/arcade-games/matching/index.ts
+++ b/apps/web/src/arcade-games/matching/index.ts
@@ -5,7 +5,7 @@
 * Supports both abacus-numeral matching and complement pairs modes.
 */

-import { defineGame } from '@/lib/arcade/game-sdk'
+import { defineGame, getGameTheme } from '@/lib/arcade/game-sdk'
 import type { GameManifest } from '@/lib/arcade/game-sdk'
 import { MemoryPairsGame } from './components/MemoryPairsGame'
 import { MatchingProvider } from './Provider'
@@ -23,9 +23,7 @@ const manifest: GameManifest = {
  maxPlayers: 4,
  difficulty: 'Intermediate',
  chips: ['👥 Multiplayer', '🎯 Strategic', '🏆 Competitive'],
-  color: 'purple',
-  gradient: 'linear-gradient(135deg, #e9d5ff, #ddd6fe)',
-  borderColor: 'purple.200',
+  ...getGameTheme('purple'),
  available: true,
 }

--- a/apps/web/src/arcade-games/memory-quiz/index.ts
+++ b/apps/web/src/arcade-games/memory-quiz/index.ts
@@ -5,7 +5,7 @@
 * Supports both cooperative and competitive multiplayer modes.
 */

-import { defineGame } from '@/lib/arcade/game-sdk'
+import { defineGame, getGameTheme } from '@/lib/arcade/game-sdk'
 import type { GameManifest } from '@/lib/arcade/game-sdk'
 import { MemoryQuizGame } from './components/MemoryQuizGame'
 import { MemoryQuizProvider } from './Provider'
@@ -23,9 +23,7 @@ const manifest: GameManifest = {
  maxPlayers: 8,
  difficulty: 'Intermediate',
  chips: ['👥 Multiplayer', '🧠 Memory', '🧮 Soroban'],
-  color: 'blue',
-  gradient: 'linear-gradient(135deg, #dbeafe, #bfdbfe)',
-  borderColor: 'blue.200',
+  ...getGameTheme('blue'),
  available: true,
 }

--- a/apps/web/src/components/GameSelector.tsx
+++ b/apps/web/src/components/GameSelector.tsx
@@ -31,7 +31,7 @@ function getAllGameConfigs() {
      maxPlayers: gameDef.manifest.maxPlayers,
      description: gameDef.manifest.description,
      longDescription: gameDef.manifest.longDescription,
-      url: `/arcade/room?game=${gameDef.manifest.name}`, // Registry games load in room
+      url: '/arcade', // Arcade page handles game selection through UI
      icon: gameDef.manifest.icon,
      chips: gameDef.manifest.chips,
      color: gameDef.manifest.color,
--- a/apps/web/src/components/nav/AddPlayerButton.tsx
+++ b/apps/web/src/components/nav/AddPlayerButton.tsx
@@ -80,7 +80,7 @@ export function AddPlayerButton({
          })
          // Close popover and navigate to room to choose game
          setShowPopover(false)
-          router.push('/arcade/room')
+          router.push('/arcade')
        },
        onError: (error) => {
          console.error('Failed to create room:', error)
@@ -111,7 +111,7 @@ export function AddPlayerButton({
            }
            // Close popover and navigate to room
            setShowPopover(false)
-            router.push('/arcade/room')
+            router.push('/arcade')
          },
        }
      )
--- a/apps/web/src/components/nav/ModerationNotifications.tsx
+++ b/apps/web/src/components/nav/ModerationNotifications.tsx
@@ -833,7 +833,7 @@ export function ModerationNotifications({
                  // Close the modal
                  onClose()
                  // Navigate to the room
-                  router.push('/arcade/room')
+                  router.push('/arcade')
                } catch (error) {
                  console.error('Failed to join room:', error)
                  showError(
--- a/apps/web/src/components/nav/ModerationPanel.tsx
+++ b/apps/web/src/components/nav/ModerationPanel.tsx
@@ -114,6 +114,9 @@ export function ModerationPanel({
    null
  )

+  // Transfer ownership confirmation state
+  const [confirmingTransferOwnership, setConfirmingTransferOwnership] = useState(false)
+
  // Auto-switch to Members tab when focusedUserId is provided
  useEffect(() => {
    if (isOpen && focusedUserId) {
@@ -171,8 +174,6 @@ export function ModerationPanel({
  }, [isOpen, roomId, members])

  const handleKick = async (userId: string) => {
-    if (!confirm('Kick this player from the room?')) return
-
    setActionLoading(`kick-${userId}`)
    try {
      const res = await fetch(`/api/arcade/rooms/${roomId}/kick`, {
@@ -414,10 +415,9 @@ export function ModerationPanel({
    const newOwner = members.find((m) => m.userId === selectedNewOwner)
    if (!newOwner) return

-    if (!confirm(`Transfer ownership to ${newOwner.displayName}? You will no longer be the host.`))
-      return
-
+    setConfirmingTransferOwnership(false)
    setActionLoading('transfer-ownership')
+
    try {
      const res = await fetch(`/api/arcade/rooms/${roomId}/transfer-ownership`, {
        method: 'POST',
@@ -436,6 +436,7 @@ export function ModerationPanel({
      showError(err instanceof Error ? err.message : 'Failed to transfer ownership')
    } finally {
      setActionLoading(null)
+      setSelectedNewOwner('') // Reset selection
    }
  }

@@ -1789,61 +1790,143 @@ export function ModerationPanel({
                      Transfer host privileges to another member. You will no longer be the host.
                    </p>

-                    <select
-                      value={selectedNewOwner}
-                      onChange={(e) => setSelectedNewOwner(e.target.value)}
-                      style={{
-                        width: '100%',
-                        padding: '10px',
-                        background: 'rgba(255, 255, 255, 0.05)',
-                        border: '1px solid rgba(75, 85, 99, 0.5)',
-                        borderRadius: '6px',
-                        color: 'rgba(209, 213, 219, 1)',
-                        fontSize: '14px',
-                        marginBottom: '12px',
-                        cursor: 'pointer',
-                      }}
-                    >
-                      <option value="">Select new owner...</option>
-                      {otherMembers.map((member) => (
-                        <option key={member.userId} value={member.userId}>
-                          {member.displayName}
-                          {member.isOnline ? ' (Online)' : ' (Offline)'}
-                        </option>
-                      ))}
-                    </select>
+                    {!confirmingTransferOwnership ? (
+                      <>
+                        <select
+                          value={selectedNewOwner}
+                          onChange={(e) => setSelectedNewOwner(e.target.value)}
+                          style={{
+                            width: '100%',
+                            padding: '10px',
+                            background: 'rgba(255, 255, 255, 0.05)',
+                            border: '1px solid rgba(75, 85, 99, 0.5)',
+                            borderRadius: '6px',
+                            color: 'rgba(209, 213, 219, 1)',
+                            fontSize: '14px',
+                            marginBottom: '12px',
+                            cursor: 'pointer',
+                          }}
+                        >
+                          <option value="">Select new owner...</option>
+                          {otherMembers.map((member) => (
+                            <option key={member.userId} value={member.userId}>
+                              {member.displayName}
+                              {member.isOnline ? ' (Online)' : ' (Offline)'}
+                            </option>
+                          ))}
+                        </select>

-                    <button
-                      type="button"
-                      onClick={handleTransferOwnership}
-                      disabled={!selectedNewOwner || actionLoading === 'transfer-ownership'}
-                      style={{
-                        width: '100%',
-                        padding: '10px',
-                        background:
-                          !selectedNewOwner || actionLoading === 'transfer-ownership'
-                            ? 'rgba(75, 85, 99, 0.3)'
-                            : 'linear-gradient(135deg, rgba(251, 146, 60, 0.8), rgba(249, 115, 22, 0.8))',
-                        color: 'white',
-                        border:
-                          !selectedNewOwner || actionLoading === 'transfer-ownership'
-                            ? '1px solid rgba(75, 85, 99, 0.5)'
-                            : '1px solid rgba(251, 146, 60, 0.6)',
-                        borderRadius: '6px',
-                        fontSize: '14px',
-                        fontWeight: '600',
-                        cursor:
-                          !selectedNewOwner || actionLoading === 'transfer-ownership'
-                            ? 'not-allowed'
-                            : 'pointer',
-                        opacity:
-                          !selectedNewOwner || actionLoading === 'transfer-ownership' ? 0.5 : 1,
-                      }}
-                    >
-                      {actionLoading === 'transfer-ownership'
-                        ? 'Transferring...'
-                        : 'Transfer Ownership'}
-                    </button>
+                        <button
+                          type="button"
+                          onClick={() => setConfirmingTransferOwnership(true)}
+                          disabled={!selectedNewOwner}
+                          style={{
+                            width: '100%',
+                            padding: '10px',
+                            background: !selectedNewOwner
+                              ? 'rgba(75, 85, 99, 0.3)'
+                              : 'linear-gradient(135deg, rgba(251, 146, 60, 0.8), rgba(249, 115, 22, 0.8))',
+                            color: 'white',
+                            border: !selectedNewOwner
+                              ? '1px solid rgba(75, 85, 99, 0.5)'
+                              : '1px solid rgba(251, 146, 60, 0.6)',
+                            borderRadius: '6px',
+                            fontSize: '14px',
+                            fontWeight: '600',
+                            cursor: !selectedNewOwner ? 'not-allowed' : 'pointer',
+                            opacity: !selectedNewOwner ? 0.5 : 1,
+                          }}
+                        >
+                          Transfer Ownership
+                        </button>
+                      </>
+                    ) : (
+                      <div>
+                        <div
+                          style={{
+                            fontSize: '13px',
+                            fontWeight: '600',
+                            color: 'rgba(251, 191, 36, 1)',
+                            marginBottom: '8px',
+                          }}
+                        >
+                          ⚠️ Confirm Transfer to{' '}
+                          {members.find((m) => m.userId === selectedNewOwner)?.displayName}?
+                        </div>
+                        <div
+                          style={{
+                            fontSize: '12px',
+                            color: 'rgba(209, 213, 219, 0.8)',
+                            marginBottom: '12px',
+                          }}
+                        >
+                          You will no longer be the host and will lose moderation privileges. This
+                          cannot be undone.
+                        </div>
+                        <div style={{ display: 'flex', gap: '8px' }}>
+                          <button
+                            type="button"
+                            onClick={() => setConfirmingTransferOwnership(false)}
+                            disabled={actionLoading === 'transfer-ownership'}
+                            style={{
+                              flex: 1,
+                              padding: '10px',
+                              background: 'rgba(75, 85, 99, 0.3)',
+                              color: 'rgba(209, 213, 219, 1)',
+                              border: '1px solid rgba(75, 85, 99, 0.5)',
+                              borderRadius: '6px',
+                              fontSize: '14px',
+                              fontWeight: '600',
+                              cursor:
+                                actionLoading === 'transfer-ownership' ? 'not-allowed' : 'pointer',
+                              opacity: actionLoading === 'transfer-ownership' ? 0.5 : 1,
+                              transition: 'all 0.2s ease',
+                            }}
+                            onMouseEnter={(e) => {
+                              if (actionLoading !== 'transfer-ownership') {
+                                e.currentTarget.style.background = 'rgba(75, 85, 99, 0.4)'
+                              }
+                            }}
+                            onMouseLeave={(e) => {
+                              if (actionLoading !== 'transfer-ownership') {
+                                e.currentTarget.style.background = 'rgba(75, 85, 99, 0.3)'
+                              }
+                            }}
+                          >
+                            Cancel
+                          </button>
+                          <button
+                            type="button"
+                            onClick={handleTransferOwnership}
+                            disabled={actionLoading === 'transfer-ownership'}
+                            style={{
+                              flex: 1,
+                              padding: '10px',
+                              background:
+                                actionLoading === 'transfer-ownership'
+                                  ? 'rgba(75, 85, 99, 0.3)'
+                                  : 'linear-gradient(135deg, rgba(251, 146, 60, 0.8), rgba(249, 115, 22, 0.8))',
+                              color: 'white',
+                              border:
+                                actionLoading === 'transfer-ownership'
+                                  ? '1px solid rgba(75, 85, 99, 0.5)'
+                                  : '1px solid rgba(251, 146, 60, 0.6)',
+                              borderRadius: '6px',
+                              fontSize: '14px',
+                              fontWeight: '600',
+                              cursor:
+                                actionLoading === 'transfer-ownership' ? 'not-allowed' : 'pointer',
+                              opacity: actionLoading === 'transfer-ownership' ? 0.5 : 1,
+                              transition: 'all 0.2s ease',
+                            }}
+                          >
+                            {actionLoading === 'transfer-ownership'
+                              ? 'Transferring...'
+                              : 'Confirm Transfer'}
+                          </button>
+                        </div>
+                      </div>
+                    )}
                  </div>
                </div>
              </div>
--- a/apps/web/src/components/nav/PendingInvitations.tsx
+++ b/apps/web/src/components/nav/PendingInvitations.tsx
@@ -68,7 +68,7 @@ export function PendingInvitations({ onInvitationChange, currentRoomId }: Pendin
      // Join the room
      await joinRoom({ roomId: invitation.roomId })
      // Navigate to the room
-      router.push('/arcade/room')
+      router.push('/arcade')
      // Refresh invitations
      await fetchInvitations()
      onInvitationChange?.()
--- a/apps/web/src/components/tutorial/TutorialPlayer.tsx
+++ b/apps/web/src/components/tutorial/TutorialPlayer.tsx
@@ -215,6 +215,9 @@ interface TutorialPlayerProps {
  initialStepIndex?: number
  isDebugMode?: boolean
  showDebugPanel?: boolean
+  hideNavigation?: boolean
+  abacusColumns?: number
+  theme?: 'light' | 'dark'
  onStepChange?: (stepIndex: number, step: TutorialStep) => void
  onStepComplete?: (stepIndex: number, step: TutorialStep, success: boolean) => void
  onTutorialComplete?: (score: number, timeSpent: number) => void
@@ -227,6 +230,9 @@ function TutorialPlayerContent({
  initialStepIndex = 0,
  isDebugMode = false,
  showDebugPanel = false,
+  hideNavigation = false,
+  abacusColumns = 5,
+  theme = 'light',
  onStepChange,
  onStepComplete,
  onTutorialComplete,
@@ -379,16 +385,20 @@ function TutorialPlayerContent({
      }

      // Convert bead diff results to StepBeadHighlight format expected by AbacusReact
-      const stepBeadHighlights: StepBeadHighlight[] = beadDiff.changes.map((change, _index) => ({
-        placeValue: change.placeValue,
-        beadType: change.beadType,
-        position: change.position,
-        direction: change.direction,
-        stepIndex: currentMultiStep, // Use current multi-step index to match AbacusReact filtering
-        order: change.order,
-      }))
+      // Filter to only include beads from columns that exist
+      const minValidPlaceValue = Math.max(0, 5 - abacusColumns)
+      const stepBeadHighlights: StepBeadHighlight[] = beadDiff.changes
+        .filter((change) => change.placeValue < abacusColumns)
+        .map((change, _index) => ({
+          placeValue: change.placeValue,
+          beadType: change.beadType,
+          position: change.position,
+          direction: change.direction,
+          stepIndex: currentMultiStep, // Use current multi-step index to match AbacusReact filtering
+          order: change.order,
+        }))

-      return stepBeadHighlights
+      return stepBeadHighlights.length > 0 ? stepBeadHighlights : undefined
    } catch (error) {
      console.error('Error generating step beads with bead diff:', error)
      return undefined
@@ -399,6 +409,7 @@ function TutorialPlayerContent({
    expectedSteps,
    currentMultiStep,
    currentStep.stepBeadHighlights,
+    abacusColumns,
  ])

  // Get the current step's bead diff summary for real-time user feedback
@@ -422,6 +433,15 @@ function TutorialPlayerContent({
  // Get current step summary for real-time user feedback
  const currentStepSummary = getCurrentStepSummary()

+  // Filter highlightBeads to only include valid columns
+  const filteredHighlightBeads = useMemo(() => {
+    if (!currentStep.highlightBeads) return undefined
+    return currentStep.highlightBeads.filter((highlight) => {
+      const placeValue = highlight.placeValue ?? 4 - (highlight.columnIndex ?? 0)
+      return placeValue < abacusColumns
+    })
+  }, [currentStep.highlightBeads, abacusColumns])
+
  // Helper function to highlight the current mathematical term in the full decomposition
  const renderHighlightedDecomposition = useCallback(() => {
    if (!fullDecomposition || expectedSteps.length === 0) return null
@@ -519,16 +539,27 @@ function TutorialPlayerContent({
      return null
    }

+    // Validate that the bead is from a column that exists
+    if (topmostBead.placeValue >= abacusColumns) {
+      // Bead is from an invalid column, skip tooltip
+      return null
+    }
+
    // Smart positioning logic: avoid covering active beads
-    const targetColumnIndex = 4 - topmostBead.placeValue // Convert placeValue to columnIndex (5 columns: 0-4)
+    // Convert placeValue to columnIndex based on actual number of columns
+    const targetColumnIndex = abacusColumns - 1 - topmostBead.placeValue

    // Check if there are any active beads (against reckoning bar OR with arrows) in columns to the left
    const hasActiveBeadsToLeft = (() => {
      // Get current abacus state - we need to check which beads are against the reckoning bar
-      const abacusDigits = currentValue.toString().padStart(5, '0').split('').map(Number)
+      const abacusDigits = currentValue
+        .toString()
+        .padStart(abacusColumns, '0')
+        .split('')
+        .map(Number)

      for (let col = 0; col < targetColumnIndex; col++) {
-        const _placeValue = 4 - col // Convert columnIndex back to placeValue
+        const placeValue = abacusColumns - 1 - col // Convert columnIndex back to placeValue
        const digitValue = abacusDigits[col]

        // Check if any beads are active (against reckoning bar) in this column
@@ -544,7 +575,7 @@ function TutorialPlayerContent({
        // Also check if this column has beads with direction arrows (from current step)
        const hasArrowsInColumn =
          currentStepBeads?.some((bead) => {
-            const beadColumnIndex = 4 - bead.placeValue
+            const beadColumnIndex = abacusColumns - 1 - bead.placeValue
            return beadColumnIndex === col && bead.direction && bead.direction !== 'none'
          }) ?? false
        if (hasArrowsInColumn) {
@@ -670,6 +701,7 @@ function TutorialPlayerContent({
    currentValue,
    currentStep,
    isMeaningfulDecomposition,
+    abacusColumns,
  ])

  // Timer for smart help detection
@@ -1003,6 +1035,9 @@ function TutorialPlayerContent({

  // Memoize custom styles calculation to avoid expensive recalculation on every render
  const customStyles = useMemo(() => {
+    // Calculate valid column range based on abacusColumns
+    const minValidColumn = 5 - abacusColumns
+
    // Start with static highlights from step configuration
    const staticHighlights: Record<number, any> = {}

@@ -1012,6 +1047,11 @@ function TutorialPlayerContent({
        const columnIndex =
          highlight.placeValue !== undefined ? 4 - highlight.placeValue : highlight.columnIndex

+        // Skip highlights for columns that don't exist
+        if (columnIndex < minValidColumn) {
+          return
+        }
+
        // Initialize column if it doesn't exist
        if (!staticHighlights[columnIndex]) {
          staticHighlights[columnIndex] = {}
@@ -1041,6 +1081,12 @@ function TutorialPlayerContent({
    const mergedHighlights = { ...staticHighlights }
    Object.keys(dynamicColumnHighlights).forEach((columnIndexStr) => {
      const columnIndex = parseInt(columnIndexStr, 10)
+
+      // Skip highlights for columns that don't exist
+      if (columnIndex < minValidColumn) {
+        return
+      }
+
      if (!mergedHighlights[columnIndex]) {
        mergedHighlights[columnIndex] = {}
      }
@@ -1049,7 +1095,7 @@ function TutorialPlayerContent({
    })

    return Object.keys(mergedHighlights).length > 0 ? { columns: mergedHighlights } : undefined
-  }, [currentStep.highlightBeads, dynamicColumnHighlights])
+  }, [currentStep.highlightBeads, dynamicColumnHighlights, abacusColumns])

  if (!currentStep) {
    return <div>No steps available</div>
@@ -1061,183 +1107,187 @@ function TutorialPlayerContent({
        display: 'flex',
        flexDirection: 'column',
        height: '100%',
-        minHeight: '600px',
+        minHeight: hideNavigation ? 'auto' : '600px',
      })} ${className || ''}`}
    >
      {/* Header */}
-      <div
-        className={css({
-          borderBottom: '1px solid',
-          borderColor: 'gray.200',
-          p: 4,
-          bg: 'white',
-        })}
-      >
+      {!hideNavigation && (
        <div
-          className={hstack({
-            justifyContent: 'space-between',
-            alignItems: 'center',
+          className={css({
+            borderBottom: '1px solid',
+            borderColor: 'gray.200',
+            p: 4,
+            bg: 'white',
          })}
        >
-          <div>
-            <h1 className={css({ fontSize: 'xl', fontWeight: 'bold' })}>{tutorial.title}</h1>
-            <p className={css({ fontSize: 'sm', color: 'gray.600' })}>
-              Step {currentStepIndex + 1} of {tutorial.steps.length}: {currentStep.title}
-            </p>
-          </div>
-
-          <div className={hstack({ gap: 2 })}>
-            {isDebugMode && (
-              <>
-                <button
-                  onClick={toggleDebugPanel}
-                  className={css({
-                    px: 3,
-                    py: 1,
-                    fontSize: 'sm',
-                    border: '1px solid',
-                    borderColor: 'blue.300',
-                    borderRadius: 'md',
-                    bg: uiState.showDebugPanel ? 'blue.100' : 'white',
-                    color: 'blue.700',
-                    cursor: 'pointer',
-                    _hover: { bg: 'blue.50' },
-                  })}
-                >
-                  Debug
-                </button>
-                <button
-                  onClick={toggleStepList}
-                  className={css({
-                    px: 3,
-                    py: 1,
-                    fontSize: 'sm',
-                    border: '1px solid',
-                    borderColor: 'gray.300',
-                    borderRadius: 'md',
-                    bg: uiState.showStepList ? 'gray.100' : 'white',
-                    cursor: 'pointer',
-                    _hover: { bg: 'gray.50' },
-                  })}
-                >
-                  Steps
-                </button>
-
-                {/* Multi-step navigation controls */}
-                {currentStep.multiStepInstructions &&
-                  currentStep.multiStepInstructions.length > 1 && (
-                    <>
-                      <div
-                        className={css({
-                          fontSize: 'xs',
-                          color: 'gray.600',
-                          px: 2,
-                          borderLeft: '1px solid',
-                          borderColor: 'gray.300',
-                          ml: 2,
-                          pl: 3,
-                        })}
-                      >
-                        Multi-Step: {currentMultiStep + 1} /{' '}
-                        {currentStep.multiStepInstructions.length}
-                      </div>
-                      <button
-                        onClick={() => dispatch({ type: 'RESET_MULTI_STEP' })}
-                        disabled={currentMultiStep === 0}
-                        className={css({
-                          px: 2,
-                          py: 1,
-                          fontSize: 'xs',
-                          border: '1px solid',
-                          borderColor: currentMultiStep === 0 ? 'gray.200' : 'orange.300',
-                          borderRadius: 'md',
-                          bg: currentMultiStep === 0 ? 'gray.100' : 'white',
-                          color: currentMultiStep === 0 ? 'gray.400' : 'orange.700',
-                          cursor: currentMultiStep === 0 ? 'not-allowed' : 'pointer',
-                          _hover: currentMultiStep === 0 ? {} : { bg: 'orange.50' },
-                        })}
-                      >
-                        ⏮ First
-                      </button>
-                      <button
-                        onClick={() => previousMultiStep()}
-                        disabled={currentMultiStep === 0}
-                        className={css({
-                          px: 2,
-                          py: 1,
-                          fontSize: 'xs',
-                          border: '1px solid',
-                          borderColor: currentMultiStep === 0 ? 'gray.200' : 'orange.300',
-                          borderRadius: 'md',
-                          bg: currentMultiStep === 0 ? 'gray.100' : 'white',
-                          color: currentMultiStep === 0 ? 'gray.400' : 'orange.700',
-                          cursor: currentMultiStep === 0 ? 'not-allowed' : 'pointer',
-                          _hover: currentMultiStep === 0 ? {} : { bg: 'orange.50' },
-                        })}
-                      >
-                        ⏪ Prev
-                      </button>
-                      <button
-                        onClick={() => advanceMultiStep()}
-                        disabled={currentMultiStep >= currentStep.multiStepInstructions.length - 1}
-                        className={css({
-                          px: 2,
-                          py: 1,
-                          fontSize: 'xs',
-                          border: '1px solid',
-                          borderColor:
-                            currentMultiStep >= currentStep.multiStepInstructions.length - 1
-                              ? 'gray.200'
-                              : 'green.300',
-                          borderRadius: 'md',
-                          bg:
-                            currentMultiStep >= currentStep.multiStepInstructions.length - 1
-                              ? 'gray.100'
-                              : 'white',
-                          color:
-                            currentMultiStep >= currentStep.multiStepInstructions.length - 1
-                              ? 'gray.400'
-                              : 'green.700',
-                          cursor:
-                            currentMultiStep >= currentStep.multiStepInstructions.length - 1
-                              ? 'not-allowed'
-                              : 'pointer',
-                          _hover:
-                            currentMultiStep >= currentStep.multiStepInstructions.length - 1
-                              ? {}
-                              : { bg: 'green.50' },
-                        })}
-                      >
-                        Next ⏩
-                      </button>
-                    </>
-                  )}
-                <label className={hstack({ gap: 2, fontSize: 'sm' })}>
-                  <input
-                    type="checkbox"
-                    checked={uiState.autoAdvance}
-                    onChange={toggleAutoAdvance}
-                  />
-                  Auto-advance
-                </label>
-              </>
-            )}
-          </div>
-        </div>
-
-        {/* Progress bar */}
-        <div className={css({ mt: 2, bg: 'gray.200', borderRadius: 'full', h: 2 })}>
          <div
-            className={css({
-              bg: 'blue.500',
-              h: 'full',
-              borderRadius: 'full',
-              transition: 'width 0.3s ease',
+            className={hstack({
+              justifyContent: 'space-between',
+              alignItems: 'center',
            })}
-            style={{ width: `${navigationState.completionPercentage}%` }}
-          />
+          >
+            <div>
+              <h1 className={css({ fontSize: 'xl', fontWeight: 'bold' })}>{tutorial.title}</h1>
+              <p className={css({ fontSize: 'sm', color: 'gray.600' })}>
+                Step {currentStepIndex + 1} of {tutorial.steps.length}: {currentStep.title}
+              </p>
+            </div>
+
+            <div className={hstack({ gap: 2 })}>
+              {isDebugMode && (
+                <>
+                  <button
+                    onClick={toggleDebugPanel}
+                    className={css({
+                      px: 3,
+                      py: 1,
+                      fontSize: 'sm',
+                      border: '1px solid',
+                      borderColor: 'blue.300',
+                      borderRadius: 'md',
+                      bg: uiState.showDebugPanel ? 'blue.100' : 'white',
+                      color: 'blue.700',
+                      cursor: 'pointer',
+                      _hover: { bg: 'blue.50' },
+                    })}
+                  >
+                    Debug
+                  </button>
+                  <button
+                    onClick={toggleStepList}
+                    className={css({
+                      px: 3,
+                      py: 1,
+                      fontSize: 'sm',
+                      border: '1px solid',
+                      borderColor: 'gray.300',
+                      borderRadius: 'md',
+                      bg: uiState.showStepList ? 'gray.100' : 'white',
+                      cursor: 'pointer',
+                      _hover: { bg: 'gray.50' },
+                    })}
+                  >
+                    Steps
+                  </button>
+
+                  {/* Multi-step navigation controls */}
+                  {currentStep.multiStepInstructions &&
+                    currentStep.multiStepInstructions.length > 1 && (
+                      <>
+                        <div
+                          className={css({
+                            fontSize: 'xs',
+                            color: 'gray.600',
+                            px: 2,
+                            borderLeft: '1px solid',
+                            borderColor: 'gray.300',
+                            ml: 2,
+                            pl: 3,
+                          })}
+                        >
+                          Multi-Step: {currentMultiStep + 1} /{' '}
+                          {currentStep.multiStepInstructions.length}
+                        </div>
+                        <button
+                          onClick={() => dispatch({ type: 'RESET_MULTI_STEP' })}
+                          disabled={currentMultiStep === 0}
+                          className={css({
+                            px: 2,
+                            py: 1,
+                            fontSize: 'xs',
+                            border: '1px solid',
+                            borderColor: currentMultiStep === 0 ? 'gray.200' : 'orange.300',
+                            borderRadius: 'md',
+                            bg: currentMultiStep === 0 ? 'gray.100' : 'white',
+                            color: currentMultiStep === 0 ? 'gray.400' : 'orange.700',
+                            cursor: currentMultiStep === 0 ? 'not-allowed' : 'pointer',
+                            _hover: currentMultiStep === 0 ? {} : { bg: 'orange.50' },
+                          })}
+                        >
+                          ⏮ First
+                        </button>
+                        <button
+                          onClick={() => previousMultiStep()}
+                          disabled={currentMultiStep === 0}
+                          className={css({
+                            px: 2,
+                            py: 1,
+                            fontSize: 'xs',
+                            border: '1px solid',
+                            borderColor: currentMultiStep === 0 ? 'gray.200' : 'orange.300',
+                            borderRadius: 'md',
+                            bg: currentMultiStep === 0 ? 'gray.100' : 'white',
+                            color: currentMultiStep === 0 ? 'gray.400' : 'orange.700',
+                            cursor: currentMultiStep === 0 ? 'not-allowed' : 'pointer',
+                            _hover: currentMultiStep === 0 ? {} : { bg: 'orange.50' },
+                          })}
+                        >
+                          ⏪ Prev
+                        </button>
+                        <button
+                          onClick={() => advanceMultiStep()}
+                          disabled={
+                            currentMultiStep >= currentStep.multiStepInstructions.length - 1
+                          }
+                          className={css({
+                            px: 2,
+                            py: 1,
+                            fontSize: 'xs',
+                            border: '1px solid',
+                            borderColor:
+                              currentMultiStep >= currentStep.multiStepInstructions.length - 1
+                                ? 'gray.200'
+                                : 'green.300',
+                            borderRadius: 'md',
+                            bg:
+                              currentMultiStep >= currentStep.multiStepInstructions.length - 1
+                                ? 'gray.100'
+                                : 'white',
+                            color:
+                              currentMultiStep >= currentStep.multiStepInstructions.length - 1
+                                ? 'gray.400'
+                                : 'green.700',
+                            cursor:
+                              currentMultiStep >= currentStep.multiStepInstructions.length - 1
+                                ? 'not-allowed'
+                                : 'pointer',
+                            _hover:
+                              currentMultiStep >= currentStep.multiStepInstructions.length - 1
+                                ? {}
+                                : { bg: 'green.50' },
+                          })}
+                        >
+                          Next ⏩
+                        </button>
+                      </>
+                    )}
+                  <label className={hstack({ gap: 2, fontSize: 'sm' })}>
+                    <input
+                      type="checkbox"
+                      checked={uiState.autoAdvance}
+                      onChange={toggleAutoAdvance}
+                    />
+                    Auto-advance
+                  </label>
+                </>
+              )}
+            </div>
+          </div>
+
+          {/* Progress bar */}
+          <div className={css({ mt: 2, bg: 'gray.200', borderRadius: 'full', h: 2 })}>
+            <div
+              className={css({
+                bg: 'blue.500',
+                h: 'full',
+                borderRadius: 'full',
+                transition: 'width 0.3s ease',
+              })}
+              style={{ width: `${navigationState.completionPercentage}%` }}
+            />
+          </div>
        </div>
-      </div>
+      )}

      <div className={hstack({ flex: 1, gap: 0 })}>
        {/* Step list sidebar */}
@@ -1313,11 +1363,18 @@ function TutorialPlayerContent({
                    fontSize: '2xl',
                    fontWeight: 'bold',
                    mb: 2,
+                    color: theme === 'dark' ? 'gray.200' : 'gray.900',
                  })}
                >
                  {currentStep.problem}
                </h2>
-                <p className={css({ fontSize: 'lg', color: 'gray.700', mb: 4 })}>
+                <p
+                  className={css({
+                    fontSize: 'lg',
+                    color: theme === 'dark' ? 'gray.400' : 'gray.700',
+                    mb: 4,
+                  })}
+                >
                  {currentStep.description}
                </p>
                {/* Hide action description for multi-step problems since it duplicates pedagogical decomposition */}
@@ -1335,12 +1392,19 @@ function TutorialPlayerContent({
                    className={css({
                      p: 5,
                      background:
-                        'linear-gradient(135deg, rgba(255,248,225,0.95) 0%, rgba(254,252,232,0.95) 50%, rgba(255,245,157,0.15) 100%)',
+                        theme === 'dark'
+                          ? 'linear-gradient(135deg, rgba(40,40,50,0.6) 0%, rgba(50,50,60,0.6) 50%, rgba(60,50,70,0.3) 100%)'
+                          : 'linear-gradient(135deg, rgba(255,248,225,0.95) 0%, rgba(254,252,232,0.95) 50%, rgba(255,245,157,0.15) 100%)',
                      backdropFilter: 'blur(10px)',
-                      border: '1px solid rgba(251,191,36,0.3)',
+                      border:
+                        theme === 'dark'
+                          ? '1px solid rgba(255,255,255,0.1)'
+                          : '1px solid rgba(251,191,36,0.3)',
                      borderRadius: 'xl',
                      boxShadow:
-                        '0 8px 32px rgba(251,191,36,0.1), 0 2px 8px rgba(0,0,0,0.05), inset 0 1px 0 rgba(255,255,255,0.6)',
+                        theme === 'dark'
+                          ? '0 4px 16px rgba(0,0,0,0.3), inset 0 1px 0 rgba(255,255,255,0.05)'
+                          : '0 8px 32px rgba(251,191,36,0.1), 0 2px 8px rgba(0,0,0,0.05), inset 0 1px 0 rgba(255,255,255,0.6)',
                      position: 'relative',
                      maxW: '600px',
                      w: 'full',
@@ -1350,7 +1414,9 @@ function TutorialPlayerContent({
                        inset: '0',
                        borderRadius: 'xl',
                        background:
-                          'linear-gradient(135deg, rgba(251,191,36,0.1) 0%, rgba(168,85,247,0.05) 100%)',
+                          theme === 'dark'
+                            ? 'linear-gradient(135deg, rgba(100,100,120,0.1) 0%, rgba(80,60,100,0.05) 100%)'
+                            : 'linear-gradient(135deg, rgba(251,191,36,0.1) 0%, rgba(168,85,247,0.05) 100%)',
                        zIndex: -1,
                      },
                    })}
@@ -1359,10 +1425,10 @@ function TutorialPlayerContent({
                      className={css({
                        fontSize: 'base',
                        fontWeight: '600',
-                        color: 'amber.900',
+                        color: theme === 'dark' ? 'gray.300' : 'amber.900',
                        mb: 4,
                        letterSpacing: 'wide',
-                        textShadow: '0 1px 2px rgba(0,0,0,0.1)',
+                        textShadow: theme === 'dark' ? 'none' : '0 1px 2px rgba(0,0,0,0.1)',
                      })}
                    >
                      Guidance
@@ -1375,18 +1441,25 @@ function TutorialPlayerContent({
                          mb: 4,
                          p: 3,
                          background:
-                            'linear-gradient(135deg, rgba(255,255,255,0.8) 0%, rgba(248,250,252,0.9) 100%)',
-                          border: '1px solid rgba(203,213,225,0.4)',
+                            theme === 'dark'
+                              ? 'linear-gradient(135deg, rgba(50,50,60,0.4) 0%, rgba(40,40,50,0.5) 100%)'
+                              : 'linear-gradient(135deg, rgba(255,255,255,0.8) 0%, rgba(248,250,252,0.9) 100%)',
+                          border:
+                            theme === 'dark'
+                              ? '1px solid rgba(255,255,255,0.1)'
+                              : '1px solid rgba(203,213,225,0.4)',
                          borderRadius: 'lg',
                          boxShadow:
-                            '0 2px 8px rgba(0,0,0,0.06), inset 0 1px 0 rgba(255,255,255,0.7)',
+                            theme === 'dark'
+                              ? '0 1px 4px rgba(0,0,0,0.3), inset 0 1px 0 rgba(255,255,255,0.05)'
+                              : '0 2px 8px rgba(0,0,0,0.06), inset 0 1px 0 rgba(255,255,255,0.7)',
                          backdropFilter: 'blur(4px)',
                        })}
                      >
-                        <p
+                        <div
                          className={css({
                            fontSize: 'base',
-                            color: 'slate.800',
+                            color: theme === 'dark' ? 'gray.300' : 'slate.800',
                            fontFamily: 'mono',
                            fontWeight: '500',
                            letterSpacing: 'tight',
@@ -1398,14 +1471,14 @@ function TutorialPlayerContent({
                            termPositions={termPositions}
                            segments={pedagogicalSegments}
                          />
-                        </p>
+                        </div>
                      </div>
                    )}

                    <div
                      className={css({
                        fontSize: 'sm',
-                        color: 'amber.800',
+                        color: theme === 'dark' ? 'gray.400' : 'amber.800',
                        fontWeight: '500',
                        lineHeight: '1.6',
                      })}
@@ -1483,17 +1556,17 @@ function TutorialPlayerContent({
              {/* Abacus */}
              <div
                className={css({
-                  bg: 'white',
+                  bg: theme === 'dark' ? 'rgba(30, 30, 40, 0.4)' : 'white',
                  border: '2px solid',
-                  borderColor: 'gray.200',
+                  borderColor: theme === 'dark' ? 'rgba(255, 255, 255, 0.1)' : 'gray.200',
                  borderRadius: 'lg',
                  p: 6,
-                  shadow: 'lg',
+                  shadow: theme === 'dark' ? '0 4px 6px rgba(0, 0, 0, 0.3)' : 'lg',
                })}
              >
                <AbacusReact
                  value={currentValue}
-                  columns={5}
+                  columns={abacusColumns}
                  interactive={true}
                  animated={true}
                  scaleFactor={2.5}
@@ -1502,7 +1575,7 @@ function TutorialPlayerContent({
                  hideInactiveBeads={abacusConfig.hideInactiveBeads}
                  soundEnabled={abacusConfig.soundEnabled}
                  soundVolume={abacusConfig.soundVolume}
-                  highlightBeads={currentStep.highlightBeads}
+                  highlightBeads={filteredHighlightBeads}
                  stepBeadHighlights={currentStepBeads}
                  currentStep={currentMultiStep}
                  showDirectionIndicators={true}
@@ -1596,57 +1669,60 @@ function TutorialPlayerContent({
          </div>

          {/* Navigation controls */}
-          <div
-            className={css({
-              borderTop: '1px solid',
-              borderColor: 'gray.200',
-              p: 4,
-              bg: 'gray.50',
-            })}
-          >
-            <div className={hstack({ justifyContent: 'space-between' })}>
-              <button
-                onClick={goToPreviousStep}
-                disabled={!navigationState.canGoPrevious}
-                className={css({
-                  px: 4,
-                  py: 2,
-                  border: '1px solid',
-                  borderColor: 'gray.300',
-                  borderRadius: 'md',
-                  bg: 'white',
-                  cursor: navigationState.canGoPrevious ? 'pointer' : 'not-allowed',
-                  opacity: navigationState.canGoPrevious ? 1 : 0.5,
-                  _hover: navigationState.canGoPrevious ? { bg: 'gray.50' } : {},
-                })}
-              >
-                ← Previous
-              </button>
+          {!hideNavigation && (
+            <div
+              className={css({
+                borderTop: '1px solid',
+                borderColor: 'gray.200',
+                p: 4,
+                bg: 'gray.50',
+              })}
+            >
+              <div className={hstack({ justifyContent: 'space-between' })}>
+                <button
+                  onClick={goToPreviousStep}
+                  disabled={!navigationState.canGoPrevious}
+                  className={css({
+                    px: 4,
+                    py: 2,
+                    border: '1px solid',
+                    borderColor: 'gray.300',
+                    borderRadius: 'md',
+                    bg: 'white',
+                    cursor: navigationState.canGoPrevious ? 'pointer' : 'not-allowed',
+                    opacity: navigationState.canGoPrevious ? 1 : 0.5,
+                    _hover: navigationState.canGoPrevious ? { bg: 'gray.50' } : {},
+                  })}
+                >
+                  ← Previous
+                </button>

-              <div className={css({ fontSize: 'sm', color: 'gray.600' })}>
-                Step {currentStepIndex + 1} of {navigationState.totalSteps}
+                <div className={css({ fontSize: 'sm', color: 'gray.600' })}>
+                  Step {currentStepIndex + 1} of {navigationState.totalSteps}
+                </div>
+
+                <button
+                  onClick={goToNextStep}
+                  disabled={!navigationState.canGoNext && !isStepCompleted}
+                  className={css({
+                    px: 4,
+                    py: 2,
+                    border: '1px solid',
+                    borderColor:
+                      navigationState.canGoNext || isStepCompleted ? 'blue.300' : 'gray.300',
+                    borderRadius: 'md',
+                    bg: navigationState.canGoNext || isStepCompleted ? 'blue.500' : 'gray.200',
+                    color: navigationState.canGoNext || isStepCompleted ? 'white' : 'gray.500',
+                    cursor:
+                      navigationState.canGoNext || isStepCompleted ? 'pointer' : 'not-allowed',
+                    _hover: navigationState.canGoNext || isStepCompleted ? { bg: 'blue.600' } : {},
+                  })}
+                >
+                  {navigationState.canGoNext ? 'Next →' : 'Complete Tutorial'}
+                </button>
              </div>
-
-              <button
-                onClick={goToNextStep}
-                disabled={!navigationState.canGoNext && !isStepCompleted}
-                className={css({
-                  px: 4,
-                  py: 2,
-                  border: '1px solid',
-                  borderColor:
-                    navigationState.canGoNext || isStepCompleted ? 'blue.300' : 'gray.300',
-                  borderRadius: 'md',
-                  bg: navigationState.canGoNext || isStepCompleted ? 'blue.500' : 'gray.200',
-                  color: navigationState.canGoNext || isStepCompleted ? 'white' : 'gray.500',
-                  cursor: navigationState.canGoNext || isStepCompleted ? 'pointer' : 'not-allowed',
-                  _hover: navigationState.canGoNext || isStepCompleted ? { bg: 'blue.600' } : {},
-                })}
-              >
-                {navigationState.canGoNext ? 'Next →' : 'Complete Tutorial'}
-              </button>
            </div>
-          </div>
+          )}
        </div>

        {/* Debug panel */}
--- a/apps/web/src/hooks/useRoomData.ts
+++ b/apps/web/src/hooks/useRoomData.ts
@@ -464,6 +464,24 @@ export function useRoomData() {
      }
    }

+    const handleOwnershipTransferred = (data: {
+      roomId: string
+      oldOwnerId: string
+      newOwnerId: string
+      newOwnerName: string
+      members: RoomMember[]
+    }) => {
+      if (data.roomId === roomData?.id) {
+        queryClient.setQueryData<RoomData | null>(roomKeys.current(), (prev) => {
+          if (!prev) return null
+          return {
+            ...prev,
+            members: data.members,
+          }
+        })
+      }
+    }
+
    socket.on('room-joined', handleRoomJoined)
    socket.on('member-joined', handleMemberJoined)
    socket.on('member-left', handleMemberLeft)
@@ -474,6 +492,7 @@ export function useRoomData() {
    socket.on('room-invitation-received', handleInvitationReceived)
    socket.on('join-request-submitted', handleJoinRequestSubmitted)
    socket.on('room-game-changed', handleRoomGameChanged)
+    socket.on('ownership-transferred', handleOwnershipTransferred)

    return () => {
      socket.off('room-joined', handleRoomJoined)
@@ -486,6 +505,7 @@ export function useRoomData() {
      socket.off('room-invitation-received', handleInvitationReceived)
      socket.off('join-request-submitted', handleJoinRequestSubmitted)
      socket.off('room-game-changed', handleRoomGameChanged)
+      socket.off('ownership-transferred', handleOwnershipTransferred)
    }
  }, [socket, roomData?.id, queryClient])

--- a/apps/web/src/lib/arcade/game-sdk/index.ts
+++ b/apps/web/src/lib/arcade/game-sdk/index.ts
@@ -82,6 +82,13 @@ export { loadManifest } from './load-manifest'
 */
 export { defineGame } from './define-game'

+/**
+ * Standard color themes for game cards
+ * Use these to ensure consistent appearance across all games
+ */
+export { getGameTheme, GAME_THEMES } from '../game-themes'
+export type { GameTheme, GameThemeName } from '../game-themes'
+
 // ============================================================================
 // Re-exports for convenience
 // ============================================================================
--- a/apps/web/src/lib/arcade/game-themes.ts
+++ b/apps/web/src/lib/arcade/game-themes.ts
@@ -0,0 +1,88 @@
+/**
+ * Standard color themes for arcade game cards
+ *
+ * Use these presets to ensure consistent, professional appearance
+ * across all game cards on the /arcade game chooser.
+ *
+ * All gradients use Panda CSS's 100-200 color range for soft pastel appearance.
+ */
+
+export interface GameTheme {
+  color: string
+  gradient: string
+  borderColor: string
+}
+
+/**
+ * Standard theme presets
+ * These use Panda CSS's color system and provide consistent styling
+ */
+export const GAME_THEMES = {
+  blue: {
+    color: 'blue',
+    gradient: 'linear-gradient(135deg, #dbeafe, #bfdbfe)', // blue.100 to blue.200
+    borderColor: '#bfdbfe', // blue.200
+  },
+  purple: {
+    color: 'purple',
+    gradient: 'linear-gradient(135deg, #e9d5ff, #ddd6fe)', // purple.100 to purple.200
+    borderColor: '#ddd6fe', // purple.200
+  },
+  green: {
+    color: 'green',
+    gradient: 'linear-gradient(135deg, #d1fae5, #a7f3d0)', // green.100 to green.200
+    borderColor: '#a7f3d0', // green.200
+  },
+  teal: {
+    color: 'teal',
+    gradient: 'linear-gradient(135deg, #ccfbf1, #99f6e4)', // teal.100 to teal.200
+    borderColor: '#99f6e4', // teal.200
+  },
+  indigo: {
+    color: 'indigo',
+    gradient: 'linear-gradient(135deg, #e0e7ff, #c7d2fe)', // indigo.100 to indigo.200
+    borderColor: '#c7d2fe', // indigo.200
+  },
+  pink: {
+    color: 'pink',
+    gradient: 'linear-gradient(135deg, #fce7f3, #fbcfe8)', // pink.100 to pink.200
+    borderColor: '#fbcfe8', // pink.200
+  },
+  orange: {
+    color: 'orange',
+    gradient: 'linear-gradient(135deg, #ffedd5, #fed7aa)', // orange.100 to orange.200
+    borderColor: '#fed7aa', // orange.200
+  },
+  yellow: {
+    color: 'yellow',
+    gradient: 'linear-gradient(135deg, #fef3c7, #fde68a)', // yellow.100 to yellow.200
+    borderColor: '#fde68a', // yellow.200
+  },
+  red: {
+    color: 'red',
+    gradient: 'linear-gradient(135deg, #fee2e2, #fecaca)', // red.100 to red.200
+    borderColor: '#fecaca', // red.200
+  },
+  gray: {
+    color: 'gray',
+    gradient: 'linear-gradient(135deg, #f3f4f6, #e5e7eb)', // gray.100 to gray.200
+    borderColor: '#e5e7eb', // gray.200
+  },
+} as const satisfies Record<string, GameTheme>
+
+export type GameThemeName = keyof typeof GAME_THEMES
+
+/**
+ * Get a standard theme by name
+ * Use this in your game manifest instead of hardcoding gradients
+ *
+ * @example
+ * const manifest: GameManifest = {
+ *   name: 'my-game',
+ *   // ... other fields
+ *   ...getGameTheme('blue')
+ * }
+ */
+export function getGameTheme(themeName: GameThemeName): GameTheme {
+  return GAME_THEMES[themeName]
+}
--- a/apps/web/src/socket-server.ts
+++ b/apps/web/src/socket-server.ts
@@ -81,7 +81,7 @@ export function initializeSocketServer(httpServer: HTTPServer) {
              session = await createArcadeSession({
                userId,
                gameName: room.gameName as GameName,
-                gameUrl: '/arcade/room',
+                gameUrl: '/arcade',
                initialState,
                activePlayers: roomPlayerIds, // Include all room members' active players
                roomId: room.id,
@@ -173,7 +173,7 @@ export function initializeSocketServer(httpServer: HTTPServer) {
            await createArcadeSession({
              userId: data.userId,
              gameName: 'matching',
-              gameUrl: '/arcade/room', // Room-based sessions use /arcade/room
+              gameUrl: '/arcade', // Room-based sessions use /arcade
              initialState,
              activePlayers,
              roomId: room.id,
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "soroban-monorepo",
-  "version": "4.10.2",
+  "version": "4.17.2",
  "private": true,
  "description": "Beautiful Soroban Flashcard Generator - Monorepo",
  "workspaces": [
--- a/packages/templates/gallery-unified.html
+++ b/packages/templates/gallery-unified.html
@@ -305,7 +305,7 @@
        <div class="stats">
            <div class="stats-info">
                <strong>13</strong> examples rendered
-                • Generated on 10/12/2025 at 2:30:55 AM
+                • Generated on 10/19/2025 at 2:34:30 AM
            </div>
        </div>