chore(release): 4.27.0 [skip ci]

## [4.27.0](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.26.0...v4.27.0) (2025-10-20) ### Features * **levels:** add Dan levels ladder visualization ([c18012c](c18012cb50))
feat(levels): add Dan levels ladder visualization
2025-10-20 12:18:57 +00:00 · 2025-10-20 07:17:51 -05:00 · 2025-10-20 12:15:15 +00:00 · 2025-10-20 07:14:16 -05:00 · 2025-10-20 12:08:33 +00:00 · 2025-10-20 07:07:34 -05:00
32 changed files with 5967 additions and 753 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,396 @@
+## [4.27.0](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.26.0...v4.27.0) (2025-10-20)
+
+
+### Features
+
+* **levels:** add Dan levels ladder visualization ([c18012c](https://github.com/antialias/soroban-abacus-flashcards/commit/c18012cb505a1f2a86ebed7579b379a4d7d97f2c))
+
+## [4.26.0](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.25.1...v4.26.0) (2025-10-20)
+
+
+### Features
+
+* **levels:** add kyu level data and cards ([6463a3b](https://github.com/antialias/soroban-abacus-flashcards/commit/6463a3b2f6371ebebac1048197fb44178997d2ef))
+
+## [4.25.1](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.25.0...v4.25.1) (2025-10-20)
+
+
+### Code Refactoring
+
+* **homepage:** make entire "Your Journey" card clickable ([3f30810](https://github.com/antialias/soroban-abacus-flashcards/commit/3f30810271418f3acf3df17e41d9a897a3312c34))
+
+## [4.25.0](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.24.3...v4.25.0) (2025-10-20)
+
+
+### Features
+
+* **levels:** add Kyu & Dan levels page with homepage link ([39b1e7d](https://github.com/antialias/soroban-abacus-flashcards/commit/39b1e7de16f15412c91cf648c714e31e2de7a6bc))
+
+
+### Styles
+
+* **homepage:** adjust journey emoji sizing and spacing ([2a0e469](https://github.com/antialias/soroban-abacus-flashcards/commit/2a0e469e83b99c88f091bfecd770e0b4c1cb6310))
+
+## [4.24.3](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.24.2...v4.24.3) (2025-10-20)
+
+
+### Code Refactoring
+
+* **homepage:** align all skill icon panes horizontally ([4b04e86](https://github.com/antialias/soroban-abacus-flashcards/commit/4b04e8673da228863d4ec1869897ee431fa3d753))
+
+## [4.24.2](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.24.1...v4.24.2) (2025-10-20)
+
+
+### Code Refactoring
+
+* **homepage:** tighten mini abacus vertical padding ([514d07e](https://github.com/antialias/soroban-abacus-flashcards/commit/514d07ecb5f65a3c0982b8e90994e1c17ebaa59c))
+
+## [4.24.1](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.24.0...v4.24.1) (2025-10-20)
+
+
+### Bug Fixes
+
+* **homepage:** adjust mini abacus container height ([c4066d6](https://github.com/antialias/soroban-abacus-flashcards/commit/c4066d687925bbe7737ebfeefdada7365ff97c6c))
+* **homepage:** fix MiniAbacus runtime error and improve sizing ([1fa0df8](https://github.com/antialias/soroban-abacus-flashcards/commit/1fa0df85f7d3988cbc61701d89476419ccf0a13c))
+* **homepage:** use correct AbacusReact API and fix clipping/styling issues ([1432afd](https://github.com/antialias/soroban-abacus-flashcards/commit/1432afd6e6bd547bd0da76dbeea1c2b71244826f))
+* **homepage:** use direct conditionals for mini abacus padding ([38ef16a](https://github.com/antialias/soroban-abacus-flashcards/commit/38ef16a8f91f8ab4ad0d717b0321e2002636fafb))
+
+
+### Styles
+
+* **homepage:** add more padding around mini abacus ([c5103d0](https://github.com/antialias/soroban-abacus-flashcards/commit/c5103d049f73a8f7ef26915edfbef9ea56d59094))
+* **homepage:** balance mini abacus padding horizontally and vertically ([2f0304e](https://github.com/antialias/soroban-abacus-flashcards/commit/2f0304eb81cdf84c21b0554c9cd4bd5478896dd8))
+* **homepage:** increase mini abacus padding to '5' ([1da9ed1](https://github.com/antialias/soroban-abacus-flashcards/commit/1da9ed1ce6995c605622fc2863f248e5e91ab9c3))
+
+## [4.24.0](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.23.0...v4.24.0) (2025-10-20)
+
+
+### Features
+
+* **homepage:** add animated mini abacus to "Read and set numbers" card ([e028e34](https://github.com/antialias/soroban-abacus-flashcards/commit/e028e342ad4bc01491e05a4ba074628155926fd8))
+
+## [4.23.0](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.22.0...v4.23.0) (2025-10-20)
+
+
+### Features
+
+* **homepage:** add more visual embellishments to learning cards ([4ec1b95](https://github.com/antialias/soroban-abacus-flashcards/commit/4ec1b952f202d50f6db287c41732ec65ca17c142))
+
+## [4.22.0](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.21.1...v4.22.0) (2025-10-20)
+
+
+### Features
+
+* **homepage:** enhance "What You'll Learn" with visual cards ([d142342](https://github.com/antialias/soroban-abacus-flashcards/commit/d1423420e653b26b2f89d9d17ae5d597807d6979))
+
+
+### Bug Fixes
+
+* **tutorial:** reduce tooltip z-index to scroll under nav bar ([47640f3](https://github.com/antialias/soroban-abacus-flashcards/commit/47640f3486c6d4a7107d59bdcce043f76fabbb1d))
+
+## [4.21.1](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.21.0...v4.21.1) (2025-10-20)
+
+
+### Code Refactoring
+
+* **homepage:** rearrange tutorial demo layout side by side ([8b4ecee](https://github.com/antialias/soroban-abacus-flashcards/commit/8b4eceebfaaaf07e38ea64c7fe015aec86ac754f))
+
+## [4.21.0](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.20.7...v4.21.0) (2025-10-20)
+
+
+### Features
+
+* **tutorial:** add silentErrors prop to suppress error messages ([8835e1c](https://github.com/antialias/soroban-abacus-flashcards/commit/8835e1c57ab8adcecefe0db082360dd98fbfaac7))
+
+## [4.20.7](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.20.6...v4.20.7) (2025-10-20)
+
+
+### Bug Fixes
+
+* **home:** use Panda CSS token() for dynamic colors and center arrows properly ([d52ba63](https://github.com/antialias/soroban-abacus-flashcards/commit/d52ba6373a4577655dc1e5f5ff4926af7f7d96c3))
+
+## [4.20.6](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.20.5...v4.20.6) (2025-10-20)
+
+
+### Bug Fixes
+
+* **homepage:** use inline styles for journey level colors ([5d85e89](https://github.com/antialias/soroban-abacus-flashcards/commit/5d85e898d65d44d8d09bee952fad44b5a9c0cd20)), closes [#4ade80](https://github.com/antialias/soroban-abacus-flashcards/issues/4ade80) [#60a5](https://github.com/antialias/soroban-abacus-flashcards/issues/60a5) [#a78](https://github.com/antialias/soroban-abacus-flashcards/issues/a78) [#fbbf24](https://github.com/antialias/soroban-abacus-flashcards/issues/fbbf24)
+
+## [4.20.5](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.20.4...v4.20.5) (2025-10-20)
+
+
+### Bug Fixes
+
+* **docker:** include Panda CSS styled-system in production image ([57fabff](https://github.com/antialias/soroban-abacus-flashcards/commit/57fabffe605d953b4a4d7e05032401cbf1ab2d14))
+
+## [4.20.4](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.20.3...v4.20.4) (2025-10-19)
+
+
+### Bug Fixes
+
+* **homepage:** use inline styles for Your Journey text contrast ([8e51390](https://github.com/antialias/soroban-abacus-flashcards/commit/8e5139001818d7013e1b2654ac707f7429316d58)), closes [#e5e7](https://github.com/antialias/soroban-abacus-flashcards/issues/e5e7) [#e5e7](https://github.com/antialias/soroban-abacus-flashcards/issues/e5e7) [#9ca3](https://github.com/antialias/soroban-abacus-flashcards/issues/9ca3) [#d1d5](https://github.com/antialias/soroban-abacus-flashcards/issues/d1d5)
+
+## [4.20.3](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.20.2...v4.20.3) (2025-10-19)
+
+
+### Bug Fixes
+
+* **homepage:** use explicit RGBA colors for Your Journey text ([9c51cc9](https://github.com/antialias/soroban-abacus-flashcards/commit/9c51cc94eec4efcab9c0b9d1190f5b79c0c7d365))
+
+## [4.20.2](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.20.1...v4.20.2) (2025-10-19)
+
+
+### Bug Fixes
+
+* **homepage:** improve text contrast in Your Journey section ([24d1200](https://github.com/antialias/soroban-abacus-flashcards/commit/24d120004dccecc1ce2f08c1b73eec902868fb23))
+* **tutorial:** resolve TypeScript errors in TutorialPlayer ([88f57ce](https://github.com/antialias/soroban-abacus-flashcards/commit/88f57ce6df125142d6ea7feec60c475926bd4929))
+
+## [4.20.1](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.20.0...v4.20.1) (2025-10-19)
+
+
+### Bug Fixes
+
+* **homepage:** correct positioning of progression arrows in Your Journey section ([3fff9ef](https://github.com/antialias/soroban-abacus-flashcards/commit/3fff9ef140bf1f462042f8319ed6c5e2a376e4ba))
+
+
+### Code Refactoring
+
+* **homepage:** move What You'll Learn above tutorial ([ca1c6d8](https://github.com/antialias/soroban-abacus-flashcards/commit/ca1c6d86029c891e019a96ba161e49b08b5be1bf))
+
+## [4.20.0](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.19.0...v4.20.0) (2025-10-19)
+
+
+### Features
+
+* **tutorial:** add hideTooltip prop and improve dark mode coaching bar ([1ee25b3](https://github.com/antialias/soroban-abacus-flashcards/commit/1ee25b3dd2f0ee9dd7ed571ba818b7ca5a247f85))
+
+## [4.19.0](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.18.1...v4.19.0) (2025-10-19)
+
+
+### Features
+
+* **tutorial:** add fill color support for dark mode column posts and reckoning bar ([2eb3ff3](https://github.com/antialias/soroban-abacus-flashcards/commit/2eb3ff340613301df20bf14f5b461371a27d7f05))
+
+## [4.18.1](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.18.0...v4.18.1) (2025-10-19)
+
+
+### Bug Fixes
+
+* **tutorial:** use correct customStyles API for dark mode frame styling ([fdc882c](https://github.com/antialias/soroban-abacus-flashcards/commit/fdc882cb046e3d8835fbca59841e9af5329bcc52))
+
+## [4.18.0](https://github.com/antialias/soroban-abacus-flashcards/compare/v4.17.2...v4.18.0) (2025-10-19)
+
+
+### Features
+
+* **tutorial:** add dark mode styling for coaching bar and abacus frame ([7e2f580](https://github.com/antialias/soroban-abacus-flashcards/commit/7e2f580877af9d21409f427778fa3569c950fcf5))
+
+## [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)


--- a/31
+++ b/31
@@ -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
@@ -44,6 +59,9 @@ RUN adduser --system --uid 1001 nextjs
 COPY --from=builder --chown=nextjs:nodejs /app/apps/web/.next ./apps/web/.next
 COPY --from=builder --chown=nextjs:nodejs /app/apps/web/public ./apps/web/public

+# Copy Panda CSS generated styles
+COPY --from=builder --chown=nextjs:nodejs /app/apps/web/styled-system ./apps/web/styled-system
+
 # Copy server files (compiled from TypeScript)
 COPY --from=builder --chown=nextjs:nodejs /app/apps/web/server.js ./apps/web/
 COPY --from=builder --chown=nextjs:nodejs /app/apps/web/dist ./apps/web/dist
@@ -55,6 +73,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/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/PANDA_CSS_DYNAMIC_TOKENS.md
+++ b/apps/web/.claude/PANDA_CSS_DYNAMIC_TOKENS.md
@@ -0,0 +1,76 @@
+# Panda CSS Dynamic Token Usage
+
+## Problem: Dynamic Color Tokens Not Working
+
+When using Panda CSS, color tokens like `blue.400`, `purple.400`, etc. don't work when used dynamically through variables in the `css()` function.
+
+## Root Cause
+
+Panda CSS's `css()` function requires **static values at build time**. It cannot process dynamic token references like:
+
+```typescript
+// ❌ This doesn't work
+const color = 'blue.400'
+css({ color: color })  // Panda can't resolve this at build time
+```
+
+The `css()` function performs static analysis during the build process to generate CSS classes. It cannot handle runtime-dynamic token paths.
+
+## Solution: Use the `token()` Function
+
+Panda CSS provides a `token()` function specifically for resolving token paths to their actual values at runtime:
+
+```typescript
+import { token } from '../../styled-system/tokens'
+
+// ✅ This works
+const stages = [
+  { level: '10 Kyu', label: 'Beginner', color: 'colors.green.400' },
+  { level: '5 Kyu', label: 'Intermediate', color: 'colors.blue.400' },
+  { level: '1 Kyu', label: 'Advanced', color: 'colors.violet.400' },
+  { level: 'Dan', label: 'Master', color: 'colors.amber.400' },
+] as const
+
+// Use with inline styles, not css()
+<div style={{ color: token(stage.color) }}>
+```
+
+## Important Notes
+
+1. **Use `as const`**: TypeScript needs the array marked as `const` so the token strings are treated as literal types, not generic strings. The `token()` function expects the `Token` literal type.
+
+2. **Use inline styles**: When using `token()`, apply colors via the `style` prop, not through the `css()` function:
+   ```typescript
+   // ✅ Correct
+   <div style={{ color: token(stage.color) }}>
+
+   // ❌ Won't work
+   <div className={css({ color: token(stage.color) })}>
+   ```
+
+3. **Static tokens in css()**: For static usage, you CAN use tokens directly in `css()`:
+   ```typescript
+   // ✅ This works because it's static
+   css({ color: 'blue.400' })
+   ```
+
+## How token() Works
+
+The `token()` function:
+- Takes a token path like `"colors.blue.400"`
+- Looks it up in the generated token registry (`styled-system/tokens/index.mjs`)
+- Returns the actual CSS value (e.g., `"#60a5fa"`)
+- Happens at runtime, not build time
+
+## Token Type Definition
+
+The `Token` type is a union of all valid token paths:
+```typescript
+type Token = "colors.blue.400" | "colors.green.400" | "colors.violet.400" | ...
+```
+
+This is defined in `styled-system/tokens/tokens.d.ts`.
+
+## Reference Implementation
+
+See `src/app/page.tsx` lines 404-434 for a working example of dynamic token usage in the "Your Journey" section.
--- 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
@@ -98,7 +98,12 @@
      "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\"\")\"\"')",
-      "WebFetch(domain:abaci.one)"
+      "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/page.tsx
+++ b/apps/web/src/app/arcade/page.tsx
@@ -1,7 +1,9 @@
 'use client'

 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'
@@ -23,7 +25,9 @@ import { getAllGames, getGame, hasGame } from '@/lib/arcade/game-registry'
 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)

  // Show loading state
  if (isLoading) {
@@ -74,9 +78,27 @@ export default function RoomPage() {

  // 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)
@@ -86,10 +108,21 @@ export default function RoomPage() {
        }

        console.log('[RoomPage] Selecting registry game:', gameType)
-        setRoomGame({
-          roomId: roomData.id,
-          gameName: 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
      }

@@ -119,13 +152,70 @@ export default function RoomPage() {
              fontSize: { base: '2xl', md: '3xl' },
              fontWeight: 'bold',
              color: 'white',
-              mb: '8',
+              mb: '4',
              textAlign: 'center',
            })}
          >
            Choose a Game
          </h1>

+          {/* 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>
+            )}
+
+            {/* 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>
+
          <div
            className={css({
              display: 'grid',
@@ -138,21 +228,22 @@ export default function RoomPage() {
            {/* 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={!isAvailable}
+                  disabled={isDisabled}
                  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,
+                    cursor: isDisabled ? 'not-allowed' : 'pointer',
+                    opacity: isDisabled ? 0.4 : 1,
                    transition: 'all 0.3s ease',
-                    _hover: !isAvailable
+                    _hover: isDisabled
                      ? {}
                      : {
                          transform: 'translateY(-4px) scale(1.02)',
@@ -193,21 +284,24 @@ export default function RoomPage() {
            {/* 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={!isAvailable}
-                  className={css({
+                  disabled={isDisabled}
+                  style={{
                    background: gameDef.manifest.gradient,
-                    border: '2px solid',
                    borderColor: gameDef.manifest.borderColor,
+                  }}
+                  className={css({
+                    border: '2px solid',
                    borderRadius: '2xl',
                    padding: '6',
-                    cursor: !isAvailable ? 'not-allowed' : 'pointer',
-                    opacity: !isAvailable ? 0.5 : 1,
+                    cursor: isDisabled ? 'not-allowed' : 'pointer',
+                    opacity: isDisabled ? 0.4 : 1,
                    transition: 'all 0.3s ease',
-                    _hover: !isAvailable
+                    _hover: isDisabled
                      ? {}
                      : {
                          transform: 'translateY(-4px) scale(1.02)',
--- a/apps/web/src/app/levels/page.tsx
+++ b/apps/web/src/app/levels/page.tsx
@@ -0,0 +1,593 @@
+'use client'
+
+import { PageWithNav } from '@/components/PageWithNav'
+import { css } from '../../../styled-system/css'
+import { container, grid, stack } from '../../../styled-system/patterns'
+
+// Kyu level data from the Japan Abacus Federation
+const kyuLevels = [
+  {
+    level: '10th Kyu',
+    emoji: '🧒',
+    color: 'green',
+    duration: '20 min',
+    passThreshold: '30%',
+    points: '60/200',
+    sections: [
+      { name: 'Addition', digits: '2-digit', problems: 10, points: 10 },
+      { name: 'Subtraction', digits: '2-digit', problems: 10, points: 10 },
+    ],
+    notes: 'No division at this level',
+  },
+  {
+    level: '9th Kyu',
+    emoji: '🧒',
+    color: 'green',
+    duration: '20 min',
+    passThreshold: '60%',
+    points: '120/200',
+    sections: [
+      { name: 'Addition', digits: '2-digit', problems: 10, points: 10 },
+      { name: 'Subtraction', digits: '2-digit', problems: 10, points: 10 },
+      { name: 'Multiplication', digits: '1×1', problems: 10, points: 10 },
+    ],
+    notes: 'Introduces multiplication',
+  },
+  {
+    level: '8th Kyu',
+    emoji: '🧒',
+    color: 'green',
+    duration: '20 min',
+    passThreshold: '60%',
+    points: '120/200',
+    sections: [
+      { name: 'Addition', digits: '3-digit', problems: 10, points: 10 },
+      { name: 'Subtraction', digits: '3-digit', problems: 10, points: 10 },
+      { name: 'Multiplication', digits: '2×1', problems: 10, points: 10 },
+      { name: 'Division', digits: '2÷1', problems: 10, points: 10 },
+    ],
+    notes: 'Introduces division',
+  },
+  {
+    level: '7th Kyu',
+    emoji: '🧒',
+    color: 'green',
+    duration: '20 min',
+    passThreshold: '60%',
+    points: '120/200',
+    sections: [
+      { name: 'Addition', digits: '4-digit', problems: 10, points: 10 },
+      { name: 'Subtraction', digits: '4-digit', problems: 10, points: 10 },
+      { name: 'Multiplication', digits: '3×1', problems: 10, points: 10 },
+      { name: 'Division', digits: '3÷1', problems: 10, points: 10 },
+    ],
+    notes: 'All four operations',
+  },
+  {
+    level: '6th Kyu',
+    emoji: '🧑',
+    color: 'blue',
+    duration: '30 min',
+    passThreshold: '70%',
+    points: '210/300',
+    sections: [
+      { name: 'Addition', digits: '5-digit', problems: 10, points: 10 },
+      { name: 'Subtraction', digits: '5-digit', problems: 10, points: 10 },
+      { name: 'Multiplication', digits: '4×2', problems: 10, points: 10 },
+      { name: 'Division', digits: '5÷2', problems: 10, points: 10 },
+    ],
+    notes: 'Longer exam time',
+  },
+  {
+    level: '5th Kyu',
+    emoji: '🧑',
+    color: 'blue',
+    duration: '30 min',
+    passThreshold: '70%',
+    points: '210/300',
+    sections: [
+      { name: 'Addition', digits: '6-digit', problems: 10, points: 10 },
+      { name: 'Subtraction', digits: '6-digit', problems: 10, points: 10 },
+      { name: 'Multiplication', digits: '5×2', problems: 10, points: 10 },
+      { name: 'Division', digits: '6÷2', problems: 10, points: 10 },
+    ],
+    notes: 'Mid-level proficiency',
+  },
+  {
+    level: '4th Kyu',
+    emoji: '🧑',
+    color: 'blue',
+    duration: '30 min',
+    passThreshold: '70%',
+    points: '210/300',
+    sections: [
+      { name: 'Addition', digits: '7-digit', problems: 10, points: 10 },
+      { name: 'Subtraction', digits: '7-digit', problems: 10, points: 10 },
+      { name: 'Multiplication', digits: '6×2', problems: 10, points: 10 },
+      { name: 'Division', digits: '7÷2', problems: 10, points: 10 },
+    ],
+    notes: 'Advanced intermediate',
+  },
+  {
+    level: '3rd Kyu',
+    emoji: '🧔',
+    color: 'violet',
+    duration: '30 min',
+    passThreshold: '80%',
+    points: '240/300',
+    sections: [
+      { name: 'Addition', digits: '8-digit', problems: 10, points: 10 },
+      { name: 'Subtraction', digits: '8-digit', problems: 10, points: 10 },
+      { name: 'Multiplication', digits: '7×2', problems: 10, points: 10 },
+      { name: 'Division', digits: '8÷2', problems: 10, points: 10 },
+    ],
+    notes: 'Higher pass threshold (80%)',
+  },
+  {
+    level: '2nd Kyu',
+    emoji: '🧔',
+    color: 'violet',
+    duration: '30 min',
+    passThreshold: '80%',
+    points: '240/300',
+    sections: [
+      { name: 'Addition', digits: '9-digit', problems: 10, points: 10 },
+      { name: 'Subtraction', digits: '9-digit', problems: 10, points: 10 },
+      { name: 'Multiplication', digits: '8×2', problems: 10, points: 10 },
+      { name: 'Division', digits: '9÷2', problems: 10, points: 10 },
+    ],
+    notes: 'Near-mastery level',
+  },
+  {
+    level: '1st Kyu',
+    emoji: '🧔',
+    color: 'violet',
+    duration: '30 min',
+    passThreshold: '80%',
+    points: '240/300',
+    sections: [
+      { name: 'Addition', digits: '10-digit', problems: 10, points: 10 },
+      { name: 'Subtraction', digits: '10-digit', problems: 10, points: 10 },
+      { name: 'Multiplication', digits: '9×2', problems: 10, points: 10 },
+      { name: 'Division', digits: '10÷2', problems: 10, points: 10 },
+    ],
+    notes: 'Highest Kyu level before Dan',
+  },
+] as const
+
+// Dan level data - score-based ranking system
+const danLevels = [
+  { level: 'Pre-1st Dan', name: 'Jun-Shodan', minScore: 90, emoji: '🧙' },
+  { level: '1st Dan', name: 'Shodan', minScore: 100, emoji: '🧙' },
+  { level: '2nd Dan', name: 'Nidan', minScore: 120, emoji: '🧙‍♂️' },
+  { level: '3rd Dan', name: 'Sandan', minScore: 140, emoji: '🧙‍♂️' },
+  { level: '4th Dan', name: 'Yondan', minScore: 160, emoji: '🧙‍♀️' },
+  { level: '5th Dan', name: 'Godan', minScore: 180, emoji: '🧙‍♀️' },
+  { level: '6th Dan', name: 'Rokudan', minScore: 200, emoji: '🧝' },
+  { level: '7th Dan', name: 'Nanadan', minScore: 220, emoji: '🧝' },
+  { level: '8th Dan', name: 'Hachidan', minScore: 250, emoji: '🧝‍♂️' },
+  { level: '9th Dan', name: 'Kudan', minScore: 270, emoji: '🧝‍♀️' },
+  { level: '10th Dan', name: 'Judan', minScore: 290, emoji: '👑' },
+] as const
+
+export default function LevelsPage() {
+  return (
+    <PageWithNav navTitle="Kyu & Dan Levels" navEmoji="📊">
+      <div className={css({ bg: 'gray.900', minHeight: '100vh' })}>
+        {/* Hero Section */}
+        <div
+          className={css({
+            background:
+              'linear-gradient(135deg, rgba(17, 24, 39, 1) 0%, rgba(124, 58, 237, 0.3) 50%, rgba(17, 24, 39, 1) 100%)',
+            color: 'white',
+            py: { base: '12', md: '16' },
+            position: 'relative',
+            overflow: 'hidden',
+          })}
+        >
+          {/* Background pattern */}
+          <div
+            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',
+            })}
+          />
+
+          <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: '3xl', md: '5xl', lg: '6xl' },
+                  fontWeight: 'bold',
+                  mb: '4',
+                  lineHeight: 'tight',
+                  background: 'linear-gradient(135deg, #fbbf24 0%, #f59e0b 50%, #fbbf24 100%)',
+                  backgroundClip: 'text',
+                  color: 'transparent',
+                })}
+              >
+                Understanding Kyu & Dan Levels
+              </h1>
+
+              {/* Subtitle */}
+              <p
+                className={css({
+                  fontSize: { base: 'lg', md: 'xl' },
+                  color: 'gray.300',
+                  mb: '6',
+                  maxW: '3xl',
+                  mx: 'auto',
+                  lineHeight: '1.6',
+                })}
+              >
+                Learn about the official Japanese soroban ranking system used by the Japan Abacus
+                Federation
+              </p>
+
+              {/* Journey progression emojis */}
+              <div
+                className={css({
+                  display: 'flex',
+                  justifyContent: 'center',
+                  alignItems: 'center',
+                  gap: '4',
+                  mb: '8',
+                  flexWrap: 'wrap',
+                })}
+              >
+                {[
+                  { emoji: '🧒', label: '10 Kyu' },
+                  { emoji: '→', label: '', isArrow: true },
+                  { emoji: '🧑', label: '5 Kyu' },
+                  { emoji: '→', label: '', isArrow: true },
+                  { emoji: '🧔', label: '1 Kyu' },
+                  { emoji: '→', label: '', isArrow: true },
+                  { emoji: '🧙', label: 'Dan' },
+                ].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' : '4xl',
+                        color: step.isArrow ? 'gray.500' : 'yellow.400',
+                      })}
+                    >
+                      {step.emoji}
+                    </div>
+                    {step.label && (
+                      <div className={css({ fontSize: 'xs', color: 'gray.400' })}>{step.label}</div>
+                    )}
+                  </div>
+                ))}
+              </div>
+            </div>
+          </div>
+        </div>
+
+        {/* Main content container */}
+        <div className={container({ maxW: '7xl', px: '4', py: '12' })}>
+          {/* Kyu Levels Section */}
+          <section className={stack({ gap: '8' })}>
+            <div className={css({ textAlign: 'center' })}>
+              <h2
+                className={css({
+                  fontSize: { base: '2xl', md: '3xl' },
+                  fontWeight: 'bold',
+                  color: 'white',
+                  mb: '4',
+                })}
+              >
+                Kyu Levels (10th to 1st)
+              </h2>
+              <p className={css({ color: 'gray.400', fontSize: 'md', mb: '8' })}>
+                Progress from beginner to advanced mastery
+              </p>
+            </div>
+
+            {/* Kyu Level Cards */}
+            <div className={grid({ columns: { base: 1, md: 2, lg: 3 }, gap: '6' })}>
+              {kyuLevels.map((kyu, index) => (
+                <div
+                  key={index}
+                  className={css({
+                    bg: 'rgba(0, 0, 0, 0.4)',
+                    border: '1px solid',
+                    borderColor:
+                      kyu.color === 'green'
+                        ? 'green.700'
+                        : kyu.color === 'blue'
+                          ? 'blue.700'
+                          : 'violet.700',
+                    rounded: 'xl',
+                    p: '6',
+                    transition: 'all 0.2s',
+                    _hover: {
+                      bg: 'rgba(0, 0, 0, 0.5)',
+                      borderColor:
+                        kyu.color === 'green'
+                          ? 'green.500'
+                          : kyu.color === 'blue'
+                            ? 'blue.500'
+                            : 'violet.500',
+                      transform: 'translateY(-2px)',
+                    },
+                  })}
+                >
+                  {/* Card Header */}
+                  <div
+                    className={css({ display: 'flex', alignItems: 'center', gap: '3', mb: '4' })}
+                  >
+                    <div className={css({ fontSize: '3xl' })}>{kyu.emoji}</div>
+                    <div>
+                      <h3
+                        className={css({
+                          fontSize: 'xl',
+                          fontWeight: 'bold',
+                          color:
+                            kyu.color === 'green'
+                              ? 'green.400'
+                              : kyu.color === 'blue'
+                                ? 'blue.400'
+                                : 'violet.400',
+                        })}
+                      >
+                        {kyu.level}
+                      </h3>
+                      <p className={css({ fontSize: 'sm', color: 'gray.400' })}>{kyu.notes}</p>
+                    </div>
+                  </div>
+
+                  {/* Exam Details */}
+                  <div className={stack({ gap: '3' })}>
+                    <div
+                      className={css({
+                        display: 'flex',
+                        justifyContent: 'space-between',
+                        fontSize: 'sm',
+                      })}
+                    >
+                      <span className={css({ color: 'gray.400' })}>Duration:</span>
+                      <span className={css({ color: 'white', fontWeight: '500' })}>
+                        {kyu.duration}
+                      </span>
+                    </div>
+                    <div
+                      className={css({
+                        display: 'flex',
+                        justifyContent: 'space-between',
+                        fontSize: 'sm',
+                      })}
+                    >
+                      <span className={css({ color: 'gray.400' })}>Pass Threshold:</span>
+                      <span className={css({ color: 'amber.400', fontWeight: '600' })}>
+                        {kyu.passThreshold}
+                      </span>
+                    </div>
+                    <div
+                      className={css({
+                        display: 'flex',
+                        justifyContent: 'space-between',
+                        fontSize: 'sm',
+                      })}
+                    >
+                      <span className={css({ color: 'gray.400' })}>Points Needed:</span>
+                      <span className={css({ color: 'white', fontWeight: '500' })}>
+                        {kyu.points}
+                      </span>
+                    </div>
+                  </div>
+
+                  {/* Sections */}
+                  <div
+                    className={css({
+                      mt: '4',
+                      pt: '4',
+                      borderTop: '1px solid',
+                      borderColor: 'gray.700',
+                    })}
+                  >
+                    <div
+                      className={css({
+                        fontSize: 'xs',
+                        color: 'gray.500',
+                        mb: '2',
+                        textTransform: 'uppercase',
+                        letterSpacing: '0.05em',
+                      })}
+                    >
+                      Problem Types
+                    </div>
+                    {kyu.sections.map((section, i) => (
+                      <div
+                        key={i}
+                        className={css({
+                          display: 'flex',
+                          justifyContent: 'space-between',
+                          fontSize: 'sm',
+                          py: '1',
+                        })}
+                      >
+                        <span className={css({ color: 'gray.300' })}>{section.name}</span>
+                        <span className={css({ color: 'gray.400', fontSize: 'xs' })}>
+                          {section.digits}
+                        </span>
+                      </div>
+                    ))}
+                  </div>
+                </div>
+              ))}
+            </div>
+          </section>
+
+          {/* Dan Levels Section */}
+          <section className={stack({ gap: '8', mt: '16' })}>
+            <div className={css({ textAlign: 'center' })}>
+              <h2
+                className={css({
+                  fontSize: { base: '2xl', md: '3xl' },
+                  fontWeight: 'bold',
+                  color: 'white',
+                  mb: '4',
+                })}
+              >
+                Dan Levels (Master Ranks)
+              </h2>
+              <p className={css({ color: 'gray.400', fontSize: 'md', mb: '8' })}>
+                Score-based ranking system for master-level practitioners
+              </p>
+            </div>
+
+            {/* Exam Requirements Box */}
+            <div
+              className={css({
+                bg: 'rgba(251, 191, 36, 0.1)',
+                border: '1px solid',
+                borderColor: 'amber.700',
+                rounded: 'xl',
+                p: '6',
+                mb: '6',
+              })}
+            >
+              <h3
+                className={css({
+                  fontSize: 'lg',
+                  fontWeight: 'bold',
+                  color: 'amber.400',
+                  mb: '3',
+                })}
+              >
+                Dan Exam Requirements
+              </h3>
+              <div className={stack({ gap: '2' })}>
+                <div className={css({ fontSize: 'sm', color: 'gray.300' })}>
+                  <strong>Duration:</strong> 30 minutes
+                </div>
+                <div className={css({ fontSize: 'sm', color: 'gray.300' })}>
+                  <strong>Problem Complexity:</strong> 3× that of 1st Kyu
+                </div>
+                <div className={css({ fontSize: 'sm', color: 'gray.300', mt: '2' })}>
+                  • Addition/Subtraction: 30-digit numbers
+                </div>
+                <div className={css({ fontSize: 'sm', color: 'gray.300' })}>
+                  • Multiplication: 27×6 digits
+                </div>
+                <div className={css({ fontSize: 'sm', color: 'gray.300' })}>
+                  • Division: 30÷6 digits
+                </div>
+              </div>
+            </div>
+
+            {/* Dan Ladder Visualization */}
+            <div
+              className={css({
+                bg: 'rgba(0, 0, 0, 0.4)',
+                border: '1px solid',
+                borderColor: 'amber.700',
+                rounded: 'xl',
+                p: { base: '6', md: '8' },
+                position: 'relative',
+              })}
+            >
+              <div className={stack({ gap: '0' })}>
+                {danLevels
+                  .slice()
+                  .reverse()
+                  .map((dan, index) => {
+                    const isTop = index === 0
+                    return (
+                      <div
+                        key={index}
+                        className={css({
+                          display: 'flex',
+                          alignItems: 'center',
+                          gap: '4',
+                          p: '3',
+                          borderBottom: !isTop ? '1px solid' : 'none',
+                          borderColor: 'gray.700',
+                          transition: 'all 0.2s',
+                          _hover: {
+                            bg: isTop ? 'rgba(251, 191, 36, 0.1)' : 'rgba(251, 191, 36, 0.05)',
+                          },
+                        })}
+                      >
+                        {/* Emoji */}
+                        <div
+                          className={css({
+                            fontSize: '3xl',
+                            minW: '12',
+                            textAlign: 'center',
+                          })}
+                        >
+                          {dan.emoji}
+                        </div>
+
+                        {/* Level Info */}
+                        <div className={css({ flex: '1' })}>
+                          <div
+                            className={css({
+                              fontSize: 'lg',
+                              fontWeight: 'bold',
+                              color: isTop ? 'amber.300' : 'amber.400',
+                            })}
+                          >
+                            {dan.level}
+                          </div>
+                          <div className={css({ fontSize: 'sm', color: 'gray.400' })}>
+                            {dan.name}
+                          </div>
+                        </div>
+
+                        {/* Score */}
+                        <div
+                          className={css({
+                            fontSize: { base: 'xl', md: '2xl' },
+                            fontWeight: 'bold',
+                            color: isTop ? 'amber.300' : 'white',
+                            minW: { base: '20', md: '24' },
+                            textAlign: 'right',
+                          })}
+                        >
+                          {dan.minScore}
+                          <span className={css({ fontSize: 'sm', color: 'gray.400', ml: '1' })}>
+                            pts
+                          </span>
+                        </div>
+                      </div>
+                    )
+                  })}
+              </div>
+
+              {/* Legend */}
+              <div
+                className={css({
+                  mt: '6',
+                  pt: '6',
+                  borderTop: '1px solid',
+                  borderColor: 'gray.700',
+                  fontSize: 'sm',
+                  color: 'gray.400',
+                  textAlign: 'center',
+                })}
+              >
+                Ranks are awarded based on total score achieved on the Dan-level exam
+              </div>
+            </div>
+          </section>
+        </div>
+      </div>
+    </PageWithNav>
+  )
+}
--- a/apps/web/src/app/page.tsx
+++ b/apps/web/src/app/page.tsx
--- a/apps/web/src/arcade-games/card-sorting/Provider.tsx
+++ b/apps/web/src/arcade-games/card-sorting/Provider.tsx
@@ -33,6 +33,9 @@ interface CardSortingContextValue {
  // UI state
  selectedCardId: string | null
  selectCard: (cardId: string | null) => void
+  // Spectator mode
+  localPlayerId: string | undefined
+  isSpectating: boolean
 }

 // Create context
@@ -546,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',
              },
            })}
          >
@@ -287,7 +295,8 @@ export function PlayingPhase() {
                  borderColor: selectedCardId === card.id ? '#1976d2' : 'transparent',
                  borderRadius: '8px',
                  background: selectedCardId === card.id ? '#e3f2fd' : 'white',
-                  cursor: 'pointer',
+                  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',
@@ -296,11 +305,13 @@ export function PlayingPhase() {
                  alignItems: 'center',
                  justifyContent: 'center',
                  boxShadow: '0 2px 6px rgba(0,0,0,0.1)',
-                  _hover: {
-                    transform: 'translateY(-5px)',
-                    boxShadow: '0 8px 16px rgba(0,0,0,0.2)',
-                    borderColor: '#2c5f76',
-                  },
+                  _hover: isSpectating
+                    ? {}
+                    : {
+                        transform: 'translateY(-5px)',
+                        boxShadow: '0 8px 16px rgba(0,0,0,0.2)',
+                        borderColor: '#2c5f76',
+                      },
                })}
                style={
                  selectedCardId === card.id
@@ -378,27 +389,29 @@ export function PlayingPhase() {
            <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',
+                    },
              })}
            >
              +
@@ -421,7 +434,8 @@ export function PlayingPhase() {
                      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',
@@ -429,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',
@@ -501,27 +518,29 @@ export function PlayingPhase() {
                    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',
                      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',
+                          },
                    })}
                  >
                    +
--- 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/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/tutorial/TutorialPlayer.tsx
+++ b/apps/web/src/components/tutorial/TutorialPlayer.tsx
@@ -215,6 +215,11 @@ interface TutorialPlayerProps {
  initialStepIndex?: number
  isDebugMode?: boolean
  showDebugPanel?: boolean
+  hideNavigation?: boolean
+  hideTooltip?: boolean
+  silentErrors?: 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 +232,11 @@ function TutorialPlayerContent({
  initialStepIndex = 0,
  isDebugMode = false,
  showDebugPanel = false,
+  hideNavigation = false,
+  hideTooltip = false,
+  silentErrors = false,
+  abacusColumns = 5,
+  theme = 'light',
  onStepChange,
  onStepComplete,
  onTutorialComplete,
@@ -379,16 +389,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 +413,7 @@ function TutorialPlayerContent({
    expectedSteps,
    currentMultiStep,
    currentStep.stepBeadHighlights,
+    abacusColumns,
  ])

  // Get the current step's bead diff summary for real-time user feedback
@@ -422,6 +437,14 @@ 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) => {
+      return highlight.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 +542,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 +578,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) {
@@ -606,7 +640,7 @@ function TutorialPlayerContent({
                  maxWidth: '200px',
                  minWidth: '150px',
                  wordBreak: 'break-word',
-                  zIndex: 1000,
+                  zIndex: 50,
                  opacity: 0.95,
                  transition: 'all 0.3s ease',
                  transform: showCelebration ? 'scale(1.05)' : 'scale(1)',
@@ -670,6 +704,7 @@ function TutorialPlayerContent({
    currentValue,
    currentStep,
    isMeaningfulDecomposition,
+    abacusColumns,
  ])

  // Timer for smart help detection
@@ -864,8 +899,8 @@ function TutorialPlayerContent({
      // Check if this is the correct action
      if (currentStep.highlightBeads && Array.isArray(currentStep.highlightBeads)) {
        const isCorrectBead = currentStep.highlightBeads.some((highlight) => {
-          // Get place value from highlight (convert columnIndex to placeValue if needed)
-          const highlightPlaceValue = highlight.placeValue ?? 4 - highlight.columnIndex
+          // Get place value from highlight
+          const highlightPlaceValue = highlight.placeValue
          // Get place value from bead click event
          const beadPlaceValue = beadInfo.bead ? beadInfo.bead.placeValue : 4 - beadInfo.columnIndex

@@ -876,10 +911,11 @@ function TutorialPlayerContent({
          )
        })

-        if (!isCorrectBead) {
+        if (!isCorrectBead && !silentErrors) {
+          const errorMessage = "That's not the highlighted bead. Try clicking the highlighted bead."
          dispatch({
            type: 'SET_ERROR',
-            error: currentStep.errorMessages.wrongBead,
+            error: errorMessage,
          })

          dispatch({
@@ -887,7 +923,7 @@ function TutorialPlayerContent({
            event: {
              type: 'ERROR_OCCURRED',
              stepId: currentStep.id,
-              error: currentStep.errorMessages.wrongBead,
+              error: errorMessage,
              timestamp: new Date(),
            },
          })
@@ -1003,14 +1039,21 @@ 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> = {}

    if (currentStep.highlightBeads && Array.isArray(currentStep.highlightBeads)) {
      currentStep.highlightBeads.forEach((highlight) => {
        // Convert placeValue to columnIndex for AbacusReact compatibility
-        const columnIndex =
-          highlight.placeValue !== undefined ? 4 - highlight.placeValue : highlight.columnIndex
+        const columnIndex = abacusColumns - 1 - highlight.placeValue
+
+        // Skip highlights for columns that don't exist
+        if (columnIndex < minValidColumn) {
+          return
+        }

        // Initialize column if it doesn't exist
        if (!staticHighlights[columnIndex]) {
@@ -1041,6 +1084,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] = {}
      }
@@ -1048,8 +1097,32 @@ function TutorialPlayerContent({
      Object.assign(mergedHighlights[columnIndex], dynamicColumnHighlights[columnIndex])
    })

-    return Object.keys(mergedHighlights).length > 0 ? { columns: mergedHighlights } : undefined
-  }, [currentStep.highlightBeads, dynamicColumnHighlights])
+    // Build the custom styles object
+    const styles: any = {}
+
+    // Add column highlights if any
+    if (Object.keys(mergedHighlights).length > 0) {
+      styles.columns = mergedHighlights
+    }
+
+    // Add frame styling for dark mode
+    if (theme === 'dark') {
+      // Column dividers (global for all columns)
+      styles.columnPosts = {
+        fill: 'rgba(255, 255, 255, 0.3)', // High contrast fill for visibility
+        stroke: 'rgba(255, 255, 255, 0.2)',
+        strokeWidth: 2,
+      }
+      // Reckoning bar (horizontal middle bar)
+      styles.reckoningBar = {
+        fill: 'rgba(255, 255, 255, 0.4)', // High contrast fill for visibility
+        stroke: 'rgba(255, 255, 255, 0.25)',
+        strokeWidth: 3,
+      }
+    }
+
+    return Object.keys(styles).length > 0 ? styles : undefined
+  }, [currentStep.highlightBeads, dynamicColumnHighlights, abacusColumns, theme])

  if (!currentStep) {
    return <div>No steps available</div>
@@ -1061,183 +1134,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: theme === 'dark' ? 'rgba(255, 255, 255, 0.1)' : 'gray.200',
+            p: 4,
+            bg: theme === 'dark' ? 'rgba(30, 30, 40, 0.6)' : '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 +1390,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 */}
@@ -1329,18 +1413,26 @@ function TutorialPlayerContent({
              </div>

              {/* Multi-step instructions panel */}
-              {currentStep.multiStepInstructions &&
+              {!hideTooltip &&
+                currentStep.multiStepInstructions &&
                currentStep.multiStepInstructions.length > 0 && (
                  <div
                    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 +1442,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 +1453,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 +1469,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 +1499,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',
                      })}
@@ -1449,7 +1550,10 @@ function TutorialPlayerContent({
                              className={css({
                                mb: 1,
                                fontWeight: 'bold',
-                                color: 'yellow.900',
+                                color: theme === 'dark' ? 'yellow.200' : 'yellow.900',
+                                textShadow:
+                                  theme === 'dark' ? '0 0 12px rgba(251, 191, 36, 0.4)' : 'none',
+                                fontSize: theme === 'dark' ? 'lg' : 'base',
                              })}
                            >
                              {currentInstruction}
@@ -1483,17 +1587,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 +1606,7 @@ function TutorialPlayerContent({
                  hideInactiveBeads={abacusConfig.hideInactiveBeads}
                  soundEnabled={abacusConfig.soundEnabled}
                  soundVolume={abacusConfig.soundVolume}
-                  highlightBeads={currentStep.highlightBeads}
+                  highlightBeads={filteredHighlightBeads}
                  stepBeadHighlights={currentStepBeads}
                  currentStep={currentMultiStep}
                  showDirectionIndicators={true}
@@ -1567,7 +1671,7 @@ function TutorialPlayerContent({
              </div>

              {/* Tooltip */}
-              {currentStep.tooltip && (
+              {!hideTooltip && currentStep.tooltip && (
                <div
                  className={css({
                    maxW: '500px',
@@ -1596,57 +1700,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/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
  "name": "soroban-monorepo",
-  "version": "4.13.5",
+  "version": "4.27.0",
  "private": true,
  "description": "Beautiful Soroban Flashcard Generator - Monorepo",
  "workspaces": [
--- a/packages/abacus-react/src/AbacusReact.tsx
+++ b/packages/abacus-react/src/AbacusReact.tsx
@@ -27,6 +27,7 @@ export interface BeadStyle {
 }

 export interface ColumnPostStyle {
+  fill?: string;
  stroke?: string;
  strokeWidth?: number;
  opacity?: number;
@@ -34,6 +35,7 @@ export interface ColumnPostStyle {
 }

 export interface ReckoningBarStyle {
+  fill?: string;
  stroke?: string;
  strokeWidth?: number;
  opacity?: number;
@@ -1979,7 +1981,10 @@ export const AbacusReact: React.FC<AbacusConfig> = ({
          const columnStyles = customStyles?.columns?.[colIndex];
          const globalColumnPosts = customStyles?.columnPosts;
          const rodStyle = {
-            fill: "rgb(0, 0, 0, 0.1)", // Default Typst color
+            fill:
+              columnStyles?.columnPost?.fill ||
+              globalColumnPosts?.fill ||
+              "rgb(0, 0, 0, 0.1)", // Default Typst color
            stroke:
              columnStyles?.columnPost?.stroke ||
              globalColumnPosts?.stroke ||
@@ -2017,8 +2022,10 @@ export const AbacusReact: React.FC<AbacusConfig> = ({
            (effectiveColumns - 1) * dimensions.rodSpacing + dimensions.beadSize
          }
          height={dimensions.barThickness}
-          fill="black" // Typst uses black
-          stroke="none"
+          fill={customStyles?.reckoningBar?.fill || "black"} // Typst default is black
+          stroke={customStyles?.reckoningBar?.stroke || "none"}
+          strokeWidth={customStyles?.reckoningBar?.strokeWidth ?? 0}
+          opacity={customStyles?.reckoningBar?.opacity ?? 1}
        />

        {/* Beads */}
--- 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>