various styling & structural changes to unify site themes; token-drop interaction changes across epic urls & views

requirements.dev.txt

@@ -2,6 +2,8 @@ asgiref==3.11.0
 attrs==25.4.0
 certifi==2025.11.12
 cffi==2.0.0
+channels
+channels-redis
 charset-normalizer==3.4.4
 coverage
 cssselect==1.3.0
@@ -23,6 +25,7 @@ pycparser==2.23
 PySocks==1.7.1
 python-dotenv
 requests==2.32.5
+scipy
 selenium==4.39.0
 sniffio==1.3.1
 sortedcontainers==2.4.0
@@ -34,6 +37,7 @@ types-PyYAML==6.0.12.20250915
 typing_extensions==4.15.0
 tzdata==2025.3
 urllib3==2.6.2
+uvicorn[standard]
 websocket-client==1.9.0
 whitenoise==6.11.0
 wsproto==1.3.2

requirements.txt

@@ -1,4 +1,6 @@
 celery
+channels
+channels-redis
 cssselect==1.3.0
 Django==6.0
 dj-database-url
@@ -13,5 +15,7 @@ lxml==6.0.2
 psycopg2-binary
 redis
 requests==2.31.0
+scipy
 stripe
 whitenoise==6.11.0
+uvicorn[standard]

src/.coveragerc

@@ -3,6 +3,7 @@ source = apps
 omit =
     */migrations/*
     */tests/*
+    */routing.py
 
 [report]
 show_missing = true

src/apps/dashboard/migrations/0003_alter_note_owner_alter_note_shared_with.py

@@ -0,0 +1,26 @@
+# Generated by Django 6.0 on 2026-03-12 19:30
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('dashboard', '0002_rename_list_to_note'),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='note',
+            name='owner',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.CASCADE, related_name='notes', to=settings.AUTH_USER_MODEL),
+        ),
+        migrations.AlterField(
+            model_name='note',
+            name='shared_with',
+            field=models.ManyToManyField(blank=True, related_name='shared_notes', to=settings.AUTH_USER_MODEL),
+        ),
+    ]

src/apps/epic/admin.py

@@ -0,0 +1,3 @@
+from django.contrib import admin
+
+# Register your models here.

src/apps/epic/apps.py

@@ -0,0 +1,5 @@
+from django.apps import AppConfig
+
+
+class EpicConfig(AppConfig):
+    name = 'apps.epic'

src/apps/epic/consumers.py

@@ -0,0 +1 @@
+# RoomConsumer goes here

src/apps/epic/migrations/0001_initial.py

@@ -0,0 +1,45 @@
+# Generated by Django 6.0 on 2026-03-12 19:46
+
+import django.db.models.deletion
+import uuid
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    initial = True
+
+    dependencies = [
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='Room',
+            fields=[
+                ('id', models.UUIDField(default=uuid.uuid4, editable=False, primary_key=True, serialize=False)),
+                ('name', models.CharField(max_length=200)),
+                ('visibility', models.CharField(choices=[('PRIVATE', 'Private'), ('PUBLIC', 'Public'), ('INVITE ONLY', 'Invite Only')], default='PRIVATE', max_length=20)),
+                ('gate_status', models.CharField(choices=[('GATHERING', 'Gathering'), ('OPEN', 'Open'), ('RENEWAL_DUE', 'Renewal Due')], default='GATHERING', max_length=20)),
+                ('renewal_period', models.DurationField(blank=True, null=True)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('board_state', models.JSONField(default=dict)),
+                ('seed_count', models.IntegerField(default=12)),
+                ('owner', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='owned_rooms', to=settings.AUTH_USER_MODEL)),
+            ],
+        ),
+        migrations.CreateModel(
+            name='GateSlot',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('slot_number', models.IntegerField()),
+                ('status', models.CharField(choices=[('EMPTY', 'Empty'), ('RESERVED', 'Reserved'), ('FILLED', 'Filled')], default='EMPTY', max_length=10)),
+                ('reserved_at', models.DateTimeField(blank=True, null=True)),
+                ('filled_at', models.DateTimeField(blank=True, null=True)),
+                ('funded_by', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='funded_slots', to=settings.AUTH_USER_MODEL)),
+                ('gamer', models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='gate_slots', to=settings.AUTH_USER_MODEL)),
+                ('room', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='gate_slots', to='epic.room')),
+            ],
+        ),
+    ]

src/apps/epic/migrations/0002_alter_room_renewal_period.py

@@ -0,0 +1,19 @@
+# Generated by Django 6.0 on 2026-03-13 20:32
+
+import datetime
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('epic', '0001_initial'),
+    ]
+
+    operations = [
+        migrations.AlterField(
+            model_name='room',
+            name='renewal_period',
+            field=models.DurationField(blank=True, default=datetime.timedelta(days=7), null=True),
+        ),
+    ]

src/apps/epic/migrations/0003_roominvite.py

@@ -0,0 +1,27 @@
+# Generated by Django 6.0 on 2026-03-13 22:19
+
+import django.db.models.deletion
+from django.conf import settings
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('epic', '0002_alter_room_renewal_period'),
+        migrations.swappable_dependency(settings.AUTH_USER_MODEL),
+    ]
+
+    operations = [
+        migrations.CreateModel(
+            name='RoomInvite',
+            fields=[
+                ('id', models.BigAutoField(auto_created=True, primary_key=True, serialize=False, verbose_name='ID')),
+                ('invitee_email', models.EmailField(max_length=254)),
+                ('status', models.CharField(choices=[('PENDING', 'Pending'), ('ACCEPTED', 'Accepted'), ('DECLINED', 'Declined')], default='PENDING', max_length=10)),
+                ('created_at', models.DateTimeField(auto_now_add=True)),
+                ('inviter', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='sent_invites', to=settings.AUTH_USER_MODEL)),
+                ('room', models.ForeignKey(on_delete=django.db.models.deletion.CASCADE, related_name='invites', to='epic.room')),
+            ],
+        ),
+    ]

src/apps/epic/models.py

@@ -0,0 +1,112 @@
+import uuid
+
+from datetime import timedelta
+from django.db import models
+from django.db.models.signals import post_save
+from django.dispatch import receiver
+from django.conf import settings
+from django.utils import timezone
+
+from apps.lyric.models import Token
+
+
+class Room(models.Model):
+    GATHERING = "GATHERING"
+    OPEN = "OPEN"
+    RENEWAL_DUE = "RENEWAL_DUE"
+    GATE_STATUS_CHOICES = [
+        (GATHERING, "GATHERING GAMERS"),
+        (OPEN, "Open"),
+        (RENEWAL_DUE, "Renewal Due"),
+    ]
+
+    PRIVATE = "PRIVATE"
+    PUBLIC = "PUBLIC"
+    INVITE_ONLY = "INVITE ONLY"
+    VISIBILITY_CHOICES = [
+        (PRIVATE, "Private"),
+        (PUBLIC, "Public"),
+        (INVITE_ONLY, "Invite Only"),
+    ]
+
+    id = models.UUIDField(primary_key=True, default=uuid.uuid4, editable=False)
+    name = models.CharField(max_length=200)
+    owner = models.ForeignKey(
+        settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="owned_rooms"
+    )
+    visibility = models.CharField(max_length=20, choices=VISIBILITY_CHOICES, default=PRIVATE)
+    gate_status = models.CharField(max_length=20, choices=GATE_STATUS_CHOICES, default=GATHERING)
+    renewal_period = models.DurationField(null=True, blank=True, default=timedelta(days=7))
+    created_at = models.DateTimeField(auto_now_add=True)
+    board_state = models.JSONField(default=dict)
+    seed_count = models.IntegerField(default=12)
+
+
+class GateSlot(models.Model):
+    EMPTY = "EMPTY"
+    RESERVED = "RESERVED"
+    FILLED = "FILLED"
+    STATUS_CHOICES = [
+        (EMPTY, "Empty"),
+        (RESERVED, "Reserved"),
+        (FILLED, "Filled"),
+    ]
+
+    room = models.ForeignKey(Room, on_delete=models.CASCADE, related_name="gate_slots")
+    slot_number = models.IntegerField()
+    gamer = models.ForeignKey(
+        settings.AUTH_USER_MODEL, null=True, blank=True,
+        on_delete=models.SET_NULL, related_name="gate_slots"
+    )
+    funded_by = models.ForeignKey(
+        settings.AUTH_USER_MODEL, null=True, blank=True,
+        on_delete=models.SET_NULL, related_name="funded_slots"
+    )
+    status = models.CharField(max_length=10, choices=STATUS_CHOICES, default=EMPTY)
+    reserved_at = models.DateTimeField(null=True, blank=True)
+    filled_at = models.DateTimeField(null=True, blank=True)
+
+
+class RoomInvite(models.Model):
+    PENDING = "PENDING"
+    ACCEPTED = "ACCEPTED"
+    DECLINED = "DECLINED"
+    STATUS_CHOICES = [
+        (PENDING, "Pending"),
+        (ACCEPTED, "Accepted"),
+        (DECLINED, "Declined"),
+    ]
+
+    room = models.ForeignKey(Room, on_delete=models.CASCADE, related_name="invites")
+    inviter = models.ForeignKey(
+        settings.AUTH_USER_MODEL, on_delete=models.CASCADE, related_name="sent_invites"
+    )
+    invitee_email = models.EmailField()
+    status = models.CharField(max_length=10, choices=STATUS_CHOICES, default=PENDING)
+    created_at = models.DateTimeField(auto_now_add=True)
+
+
+@receiver(post_save, sender=Room)
+def create_gate_slots(sender, instance, created, **kwargs):
+    if created:
+        for i in range(1, 7):
+            GateSlot.objects.create(room=instance, slot_number=i)
+
+
+def debit_token(user, slot, token):
+    if token.token_type == Token.COIN:
+        token.current_room = slot.room
+        period = slot.room.renewal_period or timedelta(days=7)
+        token.next_ready_at = timezone.now() + period
+        token.save()
+    else:
+        token.delete()
+    slot.gamer = user
+    slot.status = GateSlot.FILLED
+    slot.filled_at = timezone.now()
+    slot.save()
+
+    room = slot.room
+    if not room.gate_slots.filter(status=GateSlot.EMPTY).exists():
+        room.gate_status = Room.OPEN
+        room.save()

src/apps/epic/routing.py

@@ -0,0 +1 @@
+websocket_urlpatterns = []

src/apps/epic/tests/integrated/test_models.py

@@ -0,0 +1,105 @@
+from datetime import timedelta
+from django.db.models import Q
+from django.test import TestCase
+from django.urls import reverse
+
+from apps.lyric.models import Token, User
+from apps.epic.models import GateSlot, Room, RoomInvite, debit_token
+
+
+class RoomCreationTest(TestCase):
+    def test_creating_a_room_generates_six_gate_slots(self):
+        owner = User.objects.create(email="founder@example.com")
+        room = Room.objects.create(name="Test Room", owner=owner)
+        self.assertEqual(GateSlot.objects.filter(room=room).count(), 6)
+
+
+class DebitTokenTest(TestCase):
+    def setUp(self):
+        self.owner = User.objects.create(email="founder@example.com")
+        self.room = Room.objects.create(
+            name="Test Room",
+            owner=self.owner,
+            renewal_period=timedelta(days=7)
+        )
+        self.slot = self.room.gate_slots.get(slot_number=1)
+
+    def test_debit_free_token_consumes_token_and_fills_slot(self):
+        free_token = Token.objects.get(user=self.owner, token_type=Token.FREE)
+        debit_token(self.owner, self.slot, free_token)
+        self.assertFalse(Token.objects.filter(pk=free_token.pk).exists())
+        self.slot.refresh_from_db()
+        self.assertEqual(self.slot.status, GateSlot.FILLED)
+        self.assertEqual(self.slot.gamer, self.owner)
+
+    def test_debit_coin_does_not_consume_token(self):
+        coin_token = Token.objects.get(user=self.owner, token_type=Token.COIN)
+        debit_token(self.owner, self.slot, coin_token)
+        self.assertTrue(Token.objects.filter(pk=coin_token.pk).exists())
+        self.slot.refresh_from_db()
+        self.assertEqual(self.slot.status, GateSlot.FILLED)
+        self.assertEqual(self.slot.gamer, self.owner)
+
+    def test_debit_fills_last_slot_and_opens_gate(self):
+        for i in range(2, 7):
+            gamer = User.objects.create(email=f"g{i}@test.io")
+            slot = self.room.gate_slots.get(slot_number=i)
+            slot.gamer = gamer
+            slot.status = GateSlot.FILLED
+            slot.save()
+        free_token = Token.objects.get(user=self.owner, token_type=Token.FREE)
+        debit_token(self.owner, self.slot, free_token)
+        self.room.refresh_from_db()
+        self.assertEqual(self.room.gate_status, Room.OPEN)
+
+
+class CoinTokenInUseTest(TestCase):
+    def setUp(self):
+        self.owner = User.objects.create(email="founder@example.com")
+        self.room = Room.objects.create(
+            name="Dragon's Den",
+            owner=self.owner,
+            renewal_period=timedelta(days=7),
+        )
+        self.slot = self.room.gate_slots.get(slot_number=1)
+        self.coin = Token.objects.get(user=self.owner, token_type=Token.COIN)
+        debit_token(self.owner, self.slot, self.coin)
+        self.coin.refresh_from_db()
+
+    def test_coin_tooltip_expiry_shows_next_ready_date(self):
+        expected_date = self.coin.next_ready_at.strftime("%Y-%m-%d")
+        self.assertIn(expected_date, self.coin.tooltip_expiry())
+
+    def test_coin_tooltip_room_html_contains_anchor(self):
+        room_url = reverse("epic:gatekeeper", kwargs={"room_id": self.room.id})
+        html = self.coin.tooltip_room_html()
+        self.assertIn(f'href="{room_url}"', html)
+        self.assertIn(self.room.name, html)
+
+
+class RoomInviteTest(TestCase):
+    def setUp(self):
+        self.founder = User.objects.create(email="founder@example.com")
+        self.room = Room.objects.create(name="Dragon's Den", owner=self.founder)
+
+    def test_founder_can_invite_by_email(self):
+        invite = RoomInvite.objects.create(
+            room=self.room,
+            inviter=self.founder,
+            invitee_email="friend@example.com",
+        )
+        self.assertEqual(invite.status, RoomInvite.PENDING)
+
+    def test_invited_room_appears_in_my_games_queryset(self):
+        friend = User.objects.create(email="friend@example.com")
+        RoomInvite.objects.create(
+            room=self.room,
+            inviter=self.founder,
+            invitee_email=friend.email,
+        )
+        rooms = Room.objects.filter(
+            Q(owner=friend) |
+            Q(gate_slots__gamer=friend) |
+            Q(invites__invitee_email=friend.email, invites__status=RoomInvite.PENDING)
+        ).distinct()
+        self.assertIn(self.room, rooms)

src/apps/epic/tests/integrated/test_views.py

@@ -0,0 +1,284 @@
+from django.test import TestCase
+from django.urls import reverse
+from django.utils import timezone
+
+from apps.lyric.models import Token, User
+from apps.epic.models import GateSlot, Room, RoomInvite
+
+
+class RoomCreationViewTest(TestCase):
+    def setUp(self):
+        self.user = User.objects.create(email="founder@test.io")
+        self.client.force_login(self.user)
+
+    def test_post_creates_room_and_redirects_to_gatekeeper(self):
+        response = self.client.post(
+            reverse("epic:create_room"),
+            data={"name": "Test Room"},
+        )
+        room = Room.objects.get(owner=self.user)
+        self.assertRedirects(
+            response, reverse(
+                "epic:gatekeeper",
+                args=[room.id],
+            )
+        )
+
+    def test_post_requires_login(self):
+        self.client.logout()
+        response = self.client.post(
+            reverse("epic:create_room"),
+            data={"name": "Test Room"},
+        )
+
+    def test_create_room_get_redirects_to_gameboard(self):
+        response = self.client.get(reverse("epic:create_room"))
+        self.assertRedirects(response, "/gameboard/")
+
+
+class MyGamesContextTest(TestCase):
+    def setUp(self):
+        self.user = User.objects.create(email="gamer@example.com")
+        self.client.force_login(self.user)
+
+    def test_gameboard_context_includes_owned_rooms(self):
+        room = Room.objects.create(name="Durango", owner=self.user)
+        response = self.client.get("/gameboard/")
+        self.assertIn(room, response.context["my_games"])
+
+    def test_gameboard_context_includes_rooms_with_filled_slot(self):
+        other = User.objects.create(email="friend@example.com")
+        room = Room.objects.create(name="Their Room", owner=other)
+        slot = room.gate_slots.get(slot_number=2)
+        slot.gamer = self.user
+        slot.status = "FILLED"
+        slot.save()
+        response = self.client.get("/gameboard/")
+        self.assertIn(room, response.context["my_games"])
+
+
+class GateStatusViewTest(TestCase):
+    def setUp(self):
+        self.owner = User.objects.create(email="founder@test.io")
+        self.client.force_login(self.owner)
+        self.room = Room.objects.create(name="Test Room", owner=self.owner)
+
+    def test_gate_status_returns_empty_when_open(self):
+        self.room.gate_status = Room.OPEN
+        self.room.save()
+        response = self.client.get(reverse("epic:gate_status", kwargs={"room_id": self.room.id}))
+        self.assertEqual(response.content, b"")
+
+    def test_gate_status_returns_partial_when_gathering(self):
+        response = self.client.get(
+            reverse("epic:gate_status", kwargs={"room_id": self.room.id})
+        )
+        self.assertEqual(response.status_code, 200)
+        self.assertContains(response, "gate-modal")
+
+
+class DropTokenViewTest(TestCase):
+    def setUp(self):
+        self.gamer = User.objects.create(email="gamer@test.io")
+        self.client.force_login(self.gamer)
+        owner = User.objects.create(email="owner@test.io")
+        self.room = Room.objects.create(name="Test Room", owner=owner)
+
+    def test_drop_token_reserves_lowest_empty_slot(self):
+        self.client.post(reverse("epic:drop_token", kwargs={"room_id": self.room.id}))
+        slot = self.room.gate_slots.get(slot_number=1)
+        self.assertEqual(slot.status, GateSlot.RESERVED)
+        self.assertEqual(slot.gamer, self.gamer)
+
+    def test_drop_token_skips_already_filled_slots(self):
+        other = User.objects.create(email="other@test.io")
+        slot1 = self.room.gate_slots.get(slot_number=1)
+        slot1.gamer = other
+        slot1.status = GateSlot.FILLED
+        slot1.save()
+        self.client.post(reverse("epic:drop_token", kwargs={"room_id": self.room.id}))
+        slot2 = self.room.gate_slots.get(slot_number=2)
+        self.assertEqual(slot2.status, GateSlot.RESERVED)
+        self.assertEqual(slot2.gamer, self.gamer)
+
+    def test_drop_token_blocked_when_another_slot_reserved(self):
+        other = User.objects.create(email="other@test.io")
+        slot1 = self.room.gate_slots.get(slot_number=1)
+        slot1.gamer = other
+        slot1.status = GateSlot.RESERVED
+        slot1.reserved_at = timezone.now()
+        slot1.save()
+        self.client.post(reverse("epic:drop_token", kwargs={"room_id": self.room.id}))
+        # Slot 2 should remain EMPTY — lock held by other user
+        slot2 = self.room.gate_slots.get(slot_number=2)
+        self.assertEqual(slot2.status, GateSlot.EMPTY)
+
+    def test_drop_token_blocked_when_user_already_has_filled_slot(self):
+        slot1 = self.room.gate_slots.get(slot_number=1)
+        slot1.gamer = self.gamer
+        slot1.status = GateSlot.FILLED
+        slot1.save()
+        self.client.post(reverse("epic:drop_token", kwargs={"room_id": self.room.id}))
+        slot2 = self.room.gate_slots.get(slot_number=2)
+        self.assertEqual(slot2.status, GateSlot.EMPTY)
+
+    def test_drop_token_sets_reserved_at(self):
+        self.client.post(reverse("epic:drop_token", kwargs={"room_id": self.room.id}))
+        slot = self.room.gate_slots.get(slot_number=1)
+        self.assertIsNotNone(slot.reserved_at)
+
+    def test_drop_token_redirects_to_gatekeeper(self):
+        response = self.client.post(
+            reverse("epic:drop_token", kwargs={"room_id": self.room.id})
+        )
+        self.assertRedirects(
+            response, reverse("epic:gatekeeper", args=[self.room.id])
+        )
+
+
+class ConfirmTokenViewTest(TestCase):
+    def setUp(self):
+        self.gamer = User.objects.create(email="gamer@test.io")
+        self.client.force_login(self.gamer)
+        owner = User.objects.create(email="owner@test.io")
+        self.room = Room.objects.create(name="Test Room", owner=owner)
+        self.slot = self.room.gate_slots.get(slot_number=1)
+        self.slot.gamer = self.gamer
+        self.slot.status = GateSlot.RESERVED
+        self.slot.reserved_at = timezone.now()
+        self.slot.save()
+        Token.objects.create(user=self.gamer, token_type=Token.FREE)
+
+    def test_confirm_marks_slot_filled(self):
+        self.client.post(
+            reverse("epic:confirm_token", kwargs={"room_id": self.room.id})
+        )
+        self.slot.refresh_from_db()
+        self.assertEqual(self.slot.status, GateSlot.FILLED)
+
+    def test_confirm_sets_gate_open_when_all_slots_filled(self):
+        # Fill slots 2–6 via ORM
+        for i in range(2, 7):
+            other = User.objects.create(email=f"g{i}@test.io")
+            s = self.room.gate_slots.get(slot_number=i)
+            s.gamer = other
+            s.status = GateSlot.FILLED
+            s.save()
+        self.client.post(
+            reverse("epic:confirm_token", kwargs={"room_id": self.room.id})
+        )
+        self.room.refresh_from_db()
+        self.assertEqual(self.room.gate_status, Room.OPEN)
+
+    def test_confirm_redirects_to_gatekeeper(self):
+        response = self.client.post(
+            reverse("epic:confirm_token", kwargs={"room_id": self.room.id})
+        )
+        self.assertRedirects(
+            response, reverse("epic:gatekeeper", args=[self.room.id])
+        )
+
+    def test_confirm_does_nothing_without_reserved_slot(self):
+        self.slot.status = GateSlot.EMPTY
+        self.slot.gamer = None
+        self.slot.save()
+        self.client.post(
+            reverse("epic:confirm_token", kwargs={"room_id": self.room.id})
+        )
+        self.slot.refresh_from_db()
+        self.assertEqual(self.slot.status, GateSlot.EMPTY)
+
+
+class RejectTokenViewTest(TestCase):
+    def setUp(self):
+        self.gamer = User.objects.create(email="gamer@test.io")
+        self.client.force_login(self.gamer)
+        owner = User.objects.create(email="owner@test.io")
+        self.room = Room.objects.create(name="Test Room", owner=owner)
+        self.slot = self.room.gate_slots.get(slot_number=1)
+        self.slot.gamer = self.gamer
+        self.slot.status = GateSlot.RESERVED
+        self.slot.reserved_at = timezone.now()
+        self.slot.save()
+
+    def test_reject_clears_reserved_slot(self):
+        self.client.post(
+            reverse("epic:reject_token", kwargs={"room_id": self.room.id})
+        )
+        self.slot.refresh_from_db()
+        self.assertEqual(self.slot.status, GateSlot.EMPTY)
+        self.assertIsNone(self.slot.gamer)
+        self.assertIsNone(self.slot.reserved_at)
+
+    def test_reject_after_confirm_clears_filled_slot(self):
+        self.slot.status = GateSlot.FILLED
+        self.slot.save()
+        self.client.post(
+            reverse("epic:reject_token", kwargs={"room_id": self.room.id})
+        )
+        self.slot.refresh_from_db()
+        self.assertEqual(self.slot.status, GateSlot.EMPTY)
+        self.assertIsNone(self.slot.gamer)
+
+    def test_reject_redirects_to_gatekeeper(self):
+        response = self.client.post(
+            reverse("epic:reject_token", kwargs={"room_id": self.room.id})
+        )
+        self.assertRedirects(
+            response, reverse("epic:gatekeeper", args=[self.room.id])
+        )
+
+
+class RoomActionsViewTest(TestCase):
+    def setUp(self):
+        self.owner = User.objects.create(email="owner@test.io")
+        self.gamer = User.objects.create(email="gamer@test.io")
+        self.room = Room.objects.create(name="Test Room", owner=self.owner)
+        self.slot = self.room.gate_slots.get(slot_number=2)
+        self.slot.gamer = self.gamer
+        self.slot.status = "FILLED"
+        self.slot.save()
+        RoomInvite.objects.create(
+            room=self.room, inviter=self.owner,
+            invitee_email=self.gamer.email
+        )
+
+    def test_owner_delete_removes_room(self):
+        self.client.force_login(self.owner)
+        self.client.post(reverse("epic:delete_room", kwargs={"room_id": self.room.id}))
+        self.assertFalse(Room.objects.filter(pk=self.room.pk).exists())
+
+    def test_non_owner_delete_does_not_remove_room(self):
+        self.client.force_login(self.gamer)
+        self.client.post(reverse("epic:delete_room", kwargs={"room_id": self.room.id}))
+        self.assertTrue(Room.objects.filter(pk=self.room.pk).exists())
+
+    def test_delete_redirects_to_gameboard(self):
+        self.client.force_login(self.owner)
+        response = self.client.post(
+            reverse("epic:delete_room", kwargs={"room_id": self.room.id})
+        )
+        self.assertRedirects(response, "/gameboard/")
+
+    def test_abandon_clears_slot(self):
+        self.client.force_login(self.gamer)
+        self.client.post(reverse("epic:abandon_room", kwargs={"room_id": self.room.id}))
+        self.slot.refresh_from_db()
+        self.assertEqual(self.slot.status, "EMPTY")
+        self.assertIsNone(self.slot.gamer)
+
+    def test_abandon_deletes_pending_invite(self):
+        self.client.force_login(self.gamer)
+        self.client.post(reverse("epic:abandon_room", kwargs={"room_id": self.room.id}))
+        self.assertFalse(
+            RoomInvite.objects.filter(
+                room=self.room, invitee_email=self.gamer.email
+            ).exists()
+        )
+
+    def test_abandon_redirects_to_gameboard(self):
+        self.client.force_login(self.gamer)
+        response = self.client.post(
+            reverse("epic:abandon_room", kwargs={"room_id": self.room.id})
+        )
+        self.assertRedirects(response, "/gameboard/")

src/apps/epic/urls.py

@@ -0,0 +1,17 @@
+from django.urls import path
+from . import views
+
+
+app_name = 'epic'
+
+urlpatterns = [
+    path('rooms/create_room', views.create_room, name='create_room'),
+    path('room/<uuid:room_id>/gate/', views.gatekeeper, name='gatekeeper'),
+    path('room/<uuid:room_id>/gate/drop_token', views.drop_token, name='drop_token'),
+    path('room/<uuid:room_id>/gate/confirm_token', views.confirm_token, name='confirm_token'),
+    path('room/<uuid:room_id>/gate/reject_token', views.reject_token, name='reject_token'),
+    path('room/<uuid:room_id>/gate/invite', views.invite_gamer, name='invite_gamer'),
+    path('room/<uuid:room_id>/gate/status', views.gate_status, name='gate_status'),
+    path('room/<uuid:room_id>/delete', views.delete_room, name='delete_room'),
+    path('room/<uuid:room_id>/abandon', views.abandon_room, name='abandon_room'),
+]

src/apps/epic/views.py

@@ -0,0 +1,169 @@
+from datetime import timedelta
+
+from django.contrib.auth.decorators import login_required
+from django.http import HttpResponse
+from django.shortcuts import redirect, render
+from django.utils import timezone
+
+from apps.epic.models import GateSlot, Room, RoomInvite, debit_token
+from apps.lyric.models import Token
+
+
+RESERVE_TIMEOUT = timedelta(seconds=60)
+
+
+def _expire_reserved_slots(room):
+    cutoff = timezone.now() - RESERVE_TIMEOUT
+    room.gate_slots.filter(
+        status=GateSlot.RESERVED,
+        reserved_at__lt=cutoff,
+    ).update(status=GateSlot.EMPTY, gamer=None, reserved_at=None)
+
+
+def _gate_context(room, user):
+    _expire_reserved_slots(room)
+    slots = room.gate_slots.order_by("slot_number")
+    pending_slot = slots.filter(status=GateSlot.RESERVED).first()
+    user_reserved_slot = None
+    user_filled_slot = None
+    if user.is_authenticated:
+        user_reserved_slot = slots.filter(gamer=user, status=GateSlot.RESERVED).first()
+        user_filled_slot = slots.filter(gamer=user, status=GateSlot.FILLED).first()
+    can_drop = (
+        user.is_authenticated
+        and pending_slot is None
+        and user_reserved_slot is None
+        and user_filled_slot is None
+    )
+    is_last_slot = (
+        user_reserved_slot is not None
+        and slots.filter(status=GateSlot.EMPTY).count() == 0
+    )
+    user_can_reject = user_reserved_slot is not None or user_filled_slot is not None
+    return {
+        "slots": slots,
+        "pending_slot": pending_slot,
+        "user_reserved_slot": user_reserved_slot,
+        "user_filled_slot": user_filled_slot,
+        "can_drop": can_drop,
+        "is_last_slot": is_last_slot,
+        "user_can_reject": user_can_reject,
+    }
+
+
+@login_required
+def create_room(request):
+    if request.method == "POST":
+        name = request.POST.get("name", "").strip()
+        if name:
+            room = Room.objects.create(name=name, owner=request.user)
+            return redirect("epic:gatekeeper", room_id=room.id)
+    return redirect("/gameboard/")
+
+
+def gatekeeper(request, room_id):
+    room = Room.objects.get(id=room_id)
+    ctx = _gate_context(room, request.user)
+    ctx["room"] = room
+    return render(request, "apps/gameboard/room.html", ctx)
+
+
+@login_required
+def drop_token(request, room_id):
+    if request.method == "POST":
+        room = Room.objects.get(id=room_id)
+        if room.gate_slots.filter(status=GateSlot.RESERVED).exists():
+            return redirect("epic:gatekeeper", room_id=room_id)
+        if room.gate_slots.filter(gamer=request.user, status=GateSlot.FILLED).exists():
+            return redirect("epic:gatekeeper", room_id=room_id)
+        slot = room.gate_slots.filter(
+            status=GateSlot.EMPTY
+        ).order_by("slot_number").first()
+        if slot:
+            slot.gamer = request.user
+            slot.status = GateSlot.RESERVED
+            slot.reserved_at = timezone.now()
+            slot.save()
+    return redirect("epic:gatekeeper", room_id=room_id)
+
+
+@login_required
+def confirm_token(request, room_id):
+    if request.method == "POST":
+        room = Room.objects.get(id=room_id)
+        slot = room.gate_slots.filter(
+            gamer=request.user, status=GateSlot.RESERVED
+        ).first()
+        if slot:
+            token = (
+                request.user.tokens.filter(token_type=Token.COIN).first()
+                or request.user.tokens.filter(token_type=Token.FREE).first()
+                or request.user.tokens.filter(token_type=Token.TITHE).first()
+            )
+            if token:
+                debit_token(request.user, slot, token)
+    return redirect("epic:gatekeeper", room_id=room_id)
+
+
+@login_required
+def reject_token(request, room_id):
+    if request.method == "POST":
+        room = Room.objects.get(id=room_id)
+        slot = room.gate_slots.filter(
+            gamer=request.user,
+            status__in=[GateSlot.RESERVED, GateSlot.FILLED],
+        ).first()
+        if slot:
+            slot.gamer = None
+            slot.status = GateSlot.EMPTY
+            slot.reserved_at = None
+            slot.filled_at = None
+            slot.save()
+    return redirect("epic:gatekeeper", room_id=room_id)
+
+
+@login_required
+def invite_gamer(request, room_id):
+    if request.method == "POST":
+        room = Room.objects.get(id=room_id)
+        email = request.POST.get("invitee_email", "").strip()
+        if email:
+            RoomInvite.objects.get_or_create(
+                room=room,
+                inviter=request.user,
+                invitee_email=email,
+                defaults={"status": RoomInvite.PENDING}
+            )
+    return redirect("epic:gatekeeper", room_id=room_id)
+
+
+@login_required
+def delete_room(request, room_id):
+    if request.method == "POST":
+        room = Room.objects.get(id=room_id)
+        if request.user == room.owner:
+            room.delete()
+    return redirect("/gameboard/")
+
+
+@login_required
+def abandon_room(request, room_id):
+    if request.method == "POST":
+        room = Room.objects.get(id=room_id)
+        room.gate_slots.filter(gamer=request.user).update(
+            gamer=None, status="EMPTY", filled_at=None
+        )
+        room.invites.filter(
+            invitee_email=request.user.email,
+            status=RoomInvite.PENDING
+        ).delete()
+    return redirect("/gameboard/")
+
+
+def gate_status(request, room_id):
+    room = Room.objects.get(id=room_id)
+    if room.gate_status == Room.OPEN:
+        return HttpResponse("")
+    ctx = _gate_context(room, request.user)
+    ctx["room"] = room
+    return render(request, "apps/gameboard/_partials/_gatekeeper.html", ctx)

src/apps/epic/voronoi.py

@@ -0,0 +1 @@
+# TODO: toroidal topology (tile seeds across boundary before computing)

src/apps/gameboard/views.py

@@ -1,8 +1,10 @@
 from django.contrib.auth.decorators import login_required
+from django.db.models import Q
 from django.shortcuts import redirect, render
 
 from apps.applets.utils import applet_context
 from apps.applets.models import Applet, UserApplet
+from apps.epic.models import Room, RoomInvite
 from apps.lyric.models import Token
 
 
@@ -23,6 +25,11 @@ def gameboard(request):
             "free_tokens": free_tokens,
             "applets": applet_context(request.user, "gameboard"),
             "page_class": "page-gameboard",
+            "my_games": Room.objects.filter(
+                Q(owner=request.user) |
+                Q(gate_slots__gamer=request.user) |
+                Q(invites__invitee_email=request.user.email, invites__status=RoomInvite.PENDING)
+            ).distinct(),
         }
     )
 
@@ -40,5 +47,10 @@ def toggle_game_applets(request):
             "applets": applet_context(request.user, "gameboard"),
             "coin": request.user.tokens.filter(token_type=Token.COIN).first(),
             "free_tokens": list(request.user.tokens.filter(token_type=Token.FREE)),
+            "my_games": Room.objects.filter(
+                Q(owner=request.user) |
+                Q(gate_slots__gamer=request.user) |
+                Q(invites__invitee_email=request.user.email, invites__status=RoomInvite.PENDING)
+            ).distinct(),
         })
     return redirect("gameboard")

src/apps/lyric/migrations/0008_token_current_room_token_next_ready_at.py

@@ -0,0 +1,25 @@
+# Generated by Django 6.0 on 2026-03-13 20:17
+
+import django.db.models.deletion
+from django.db import migrations, models
+
+
+class Migration(migrations.Migration):
+
+    dependencies = [
+        ('epic', '0001_initial'),
+        ('lyric', '0007_user_stripe_customer_id_paymentmethod'),
+    ]
+
+    operations = [
+        migrations.AddField(
+            model_name='token',
+            name='current_room',
+            field=models.ForeignKey(blank=True, null=True, on_delete=django.db.models.deletion.SET_NULL, related_name='coin_tokens', to='epic.room'),
+        ),
+        migrations.AddField(
+            model_name='token',
+            name='next_ready_at',
+            field=models.DateTimeField(blank=True, null=True),
+        ),
+    ]

src/apps/lyric/models.py

@@ -5,6 +5,7 @@ from django.contrib.auth.base_user import AbstractBaseUser, BaseUserManager
 from django.db import models
 from django.db.models.signals import post_save
 from django.dispatch import receiver
+from django.urls import reverse
 from django.utils import timezone
 
 
@@ -79,6 +80,11 @@ class Token(models.Model):
     user = models.ForeignKey(User, on_delete=models.CASCADE, related_name="tokens")
     token_type = models.CharField(max_length=8, choices=TOKEN_TYPE_CHOICES)
     expires_at = models.DateTimeField(null=True, blank=True)
+    current_room = models.ForeignKey(
+        "epic.Room", null=True, blank=True,
+        on_delete=models.SET_NULL, related_name="coin_tokens"
+    )
+    next_ready_at = models.DateTimeField(null=True, blank=True)
 
     def tooltip_name(self):
         return self.get_token_type_display()
@@ -92,11 +98,19 @@ class Token(models.Model):
 
     def tooltip_expiry(self):
         if self.token_type == self.COIN:
+            if self.next_ready_at:
+                return f"Ready {self.next_ready_at.strftime('%Y-%m-%d')}"
             return "no expiry"
         if self.expires_at:
             return f"Expires {self.expires_at.strftime('%Y-%m-%d')}"
         return ""
     
+    def tooltip_room_html(self):
+        if not self.current_room_id:
+            return ""
+        url = reverse("epic:gatekeeper", kwargs={"room_id": self.current_room_id})
+        return f'<a href="{url}">{self.current_room.name}</a>'
+
     def tooltip_shoptalk(self):
         if self.token_type == self.COIN:
             return "\u2026and another after that, and another after that\u2026"

src/apps/lyric/tests/integrated/test_models.py

@@ -143,6 +143,10 @@ class TokenTooltipTest(TestCase):
         free = Token.objects.get(user=self.user, token_type=Token.FREE)
         self.assertIsNone(free.tooltip_shoptalk())
 
+    def test_tooltip_room_html_returns_empty_when_no_room(self):
+        token = Token.objects.get(user=self.user, token_type=Token.COIN)
+        self.assertEqual(token.tooltip_room_html(), "")
+
 
 class PaymentMethodTest(TestCase):
     def setUp(self):

src/core/asgi.py

@@ -1,16 +1,19 @@
-"""
-ASGI config for core project.
-
-It exposes the ASGI callable as a module-level variable named ``application``.
-
-For more information on this file, see
-https://docs.djangoproject.com/en/6.0/howto/deployment/asgi/
-"""
-
 import os
 
 from django.core.asgi import get_asgi_application
+from channels.routing import ProtocolTypeRouter, URLRouter
+from channels.auth import AuthMiddlewareStack
+
+import apps.epic.routing
+
 
 os.environ.setdefault('DJANGO_SETTINGS_MODULE', 'core.settings')
 
-application = get_asgi_application()
+application = ProtocolTypeRouter({
+    'http': get_asgi_application(),
+    'websocket': AuthMiddlewareStack(
+        URLRouter(
+            apps.epic.routing.websocket_urlpatterns
+        )
+    ),
+})

src/core/settings.py

@@ -59,11 +59,13 @@ INSTALLED_APPS = [
     'apps.gameboard',
     # Gamer apps
     'apps.lyric',
+    'apps.epic',
     # Custom apps
     'apps.api',
     'apps.applets',
     'functional_tests',
     # Depend apps
+    'channels',
     'compressor',
     'rest_framework',
 ]
@@ -119,7 +121,7 @@ else:
         }
     }
 
-# Celery & Redis
+# Celery & Redis & Channels (oh my)
 CELERY_BROKER_URL = os.environ.get('CELERY_BROKER_URL', 'redis://localhost:6379/0')
 REDIS_URL = os.environ.get('REDIS_URL')
 if REDIS_URL:
@@ -130,6 +132,14 @@ if REDIS_URL:
         }
     }
     SESSION_ENGINE = 'django.contrib.sessions.backends.cached_db'
+CHANNEL_LAYERS = {
+    'default': {
+        'BACKEND': 'channels_redis.core.RedisChannelLayer',
+        'CONFIG': {
+            'hosts': [os.environ.get('REDIS_URL', 'redis://localhost:6379/1')],
+        },
+    }
+}
 
 # Password validation
 # https://docs.djangoproject.com/en/6.0/ref/settings/#auth-password-validators

src/core/urls.py

@@ -12,6 +12,7 @@ urlpatterns = [
     path('dashboard/', include('apps.dashboard.urls')),
     path('lyric/', include('apps.lyric.urls')),
     path('gameboard/', include('apps.gameboard.urls')),
+    path('gameboard/', include('apps.epic.urls')),
 ]
 
 # Please remove the following urlpattern

src/functional_tests/test_gatekeeper.py

@@ -0,0 +1,378 @@
+import time
+
+from django.utils import timezone
+
+from selenium.webdriver.common.by import By
+
+from .base import FunctionalTest
+from apps.applets.models import Applet
+from apps.epic.models import Room, GateSlot
+from apps.lyric.models import User
+
+
+class GatekeeperTest(FunctionalTest):
+    def setUp(self):
+        super().setUp()
+        Applet.objects.get_or_create(
+            slug="new-game", defaults={"name": "New Game", "context": "gameboard"}
+        )
+        Applet.objects.get_or_create(
+            slug="my-games", defaults={"name": "My Games", "context": "gameboard"}
+        )
+
+    def test_founder_creates_room_and_sees_gatekeeper(self):
+        # 1. Log in, navigate to gameboard
+        self.create_pre_authenticated_session("founder@test.io")
+        self.browser.get(self.live_server_url + "/gameboard/")
+        # 2. New Game applet has room name input, create button
+        self.wait_for(
+            lambda: self.browser.find_element(By.ID, "id_applet_new_game")
+        )
+        self.browser.find_element(By.ID, "id_new_game_name").send_keys("Test Room")
+        self.browser.find_element(By.ID, "id_create_game_btn").click()
+        # 3. User is redirected to Gatekeeper page for new room
+        self.wait_for(
+            lambda: self.assertIn("/gameboard/room/", self.browser.current_url)
+        )
+        self.wait_for(
+            lambda: self.assertIn("/gate/", self.browser.current_url)
+        )
+        # 4. Page shows room name, GATHERING status
+        body = self.browser.find_element(By.TAG_NAME, "body")
+        self.assertIn("Test Room", body.text)
+        self.assertIn("GATHERING GAMERS", body.text)
+        # 5. Six token slot circles are visible, all empty
+        slots = self.browser.find_elements(By.CSS_SELECTOR, ".gate-slot")
+        self.assertEqual(len(slots), 6)
+        for slot in slots:
+            self.assertIn("empty", slot.get_attribute("class"))
+        # 6. Shared coin slot is present; no individual drop buttons
+        self.browser.find_element(By.CSS_SELECTOR, ".token-slot")
+        self.assertEqual(
+            len(self.browser.find_elements(By.CSS_SELECTOR, ".drop-token-btn")), 0
+        )
+
+    def test_founder_drops_token_and_slot_fills(self):
+        # 1. Set up: log in, create room, arrive at gatekeeper
+        self.create_pre_authenticated_session("founder@test.io")
+        self.browser.get(self.live_server_url + "/gameboard/")
+        self.wait_for(
+            lambda: self.browser.find_element(By.ID, "id_new_game_name")
+        )
+        self.browser.find_element(By.ID, "id_new_game_name").send_keys("Dragon's Den")
+        self.browser.find_element(By.ID, "id_create_game_btn").click()
+        self.wait_for(
+            lambda: self.assertIn("/gate/", self.browser.current_url)
+        )
+        # 2. Founder clicks Insert Token via the shared coin slot
+        self.wait_for(
+            lambda: self.browser.find_element(By.CSS_SELECTOR, ".token-insert-btn")
+        ).click()
+        # 3. Slot 1 (lowest) now shows OK button; slot is reserved
+        ok_btn = self.wait_for(
+            lambda: self.browser.find_element(
+                By.CSS_SELECTOR, ".gate-slot[data-slot='1'] .btn-confirm"
+            )
+        )
+        # 4. Founder clicks OK → slot fills
+        ok_btn.click()
+        self.wait_for(
+            lambda: self.browser.find_element(By.CSS_SELECTOR, ".gate-slot.filled")
+        )
+        slots = self.browser.find_elements(By.CSS_SELECTOR, ".gate-slot")
+        self.assertIn("filled", slots[0].get_attribute("class"))
+        self.assertEqual(
+            len(self.browser.find_elements(By.CSS_SELECTOR, ".btn-confirm")), 0
+        )
+
+    def test_room_appears_in_my_games_after_creation(self):
+        # 1. Set up founder, game room, name
+        self.create_pre_authenticated_session("founder@test.io")
+        self.browser.get(self.live_server_url + "/gameboard/")
+        self.wait_for(
+            lambda: self.browser.find_element(By.ID, "id_new_game_name")
+        )
+        self.browser.find_element(By.ID, "id_new_game_name").send_keys("Dragon's Den")
+        self.browser.find_element(By.ID, "id_create_game_btn").click()
+        self.wait_for(
+            lambda: self.assertIn("/gate/", self.browser.current_url)
+        )
+        # 2. Navigate back to gameboard
+        self.browser.get(self.live_server_url + "/gameboard/")
+        my_games = self.wait_for(
+            lambda: self.browser.find_element(By.ID, "id_applet_my_games")
+        )
+        self.assertIn("Dragon's Den", my_games.text)
+
+    def test_second_gamer_drops_token_into_open_slot(self):
+        # 1. Founder creates room, confirms slot 1
+        self.create_pre_authenticated_session("founder@test.io")
+        self.browser.get(self.live_server_url + "/gameboard/")
+        self.wait_for(
+            lambda: self.browser.find_element(By.ID, "id_new_game_name")
+        )
+        self.browser.find_element(By.ID, "id_new_game_name").send_keys("Dragon's Den")
+        self.browser.find_element(By.ID, "id_create_game_btn").click()
+        self.wait_for(
+            lambda: self.assertIn("/gate/", self.browser.current_url)
+        )
+        room_url = self.browser.current_url
+        self.wait_for(
+            lambda: self.browser.find_element(By.CSS_SELECTOR, ".token-insert-btn")
+        ).click()
+        self.wait_for(
+            lambda: self.browser.find_element(By.CSS_SELECTOR, ".btn-confirm")
+        ).click()
+        self.wait_for(
+            lambda: self.browser.find_element(By.CSS_SELECTOR, ".gate-slot.filled")
+        )
+        # 2. Founder invites friend
+        invite_input = self.wait_for(
+            lambda: self.browser.find_element(By.ID, "id_invite_email")
+        )
+        invite_input.send_keys("friend@test.io")
+        self.browser.find_element(By.ID, "id_invite_btn").click()
+        # 3. Friend logs in, sees invitation in My Games
+        self.create_pre_authenticated_session("friend@test.io")
+        self.browser.get(self.live_server_url + "/gameboard/")
+        my_games = self.wait_for(
+            lambda: self.browser.find_element(By.ID, "id_applet_my_games")
+        )
+        self.assertIn("Dragon's Den", my_games.text)
+        # 4. Friend follows link to gatekeeper
+        self.browser.find_element(By.LINK_TEXT, "Dragon's Den").click()
+        # 5. Friend drops token via coin slot and confirms
+        self.wait_for(
+            lambda: self.browser.find_element(By.CSS_SELECTOR, ".token-insert-btn")
+        ).click()
+        self.wait_for(
+            lambda: self.browser.find_element(By.CSS_SELECTOR, ".btn-confirm")
+        ).click()
+        # 6. Now two slots filled
+        self.wait_for(
+            lambda: self.assertEqual(
+                len(self.browser.find_elements(By.CSS_SELECTOR, ".gate-slot.filled")), 2
+            )
+        )
+
+    def test_gate_opens_when_all_slots_filled(self):
+        # 1. Founder creates room
+        self.create_pre_authenticated_session("founder@test.io")
+        self.browser.get(self.live_server_url + "/gameboard/")
+        self.wait_for(
+            lambda: self.browser.find_element(By.ID, "id_new_game_name")
+        )
+        self.browser.find_element(By.ID, "id_new_game_name").send_keys("Dragon's Den")
+        self.browser.find_element(By.ID, "id_create_game_btn").click()
+        self.wait_for(
+            lambda: self.assertIn("/gate/", self.browser.current_url)
+        )
+        # 2. Founder confirms slot 1 via coin slot
+        self.wait_for(
+            lambda: self.browser.find_element(By.CSS_SELECTOR, ".token-insert-btn")
+        ).click()
+        self.wait_for(
+            lambda: self.browser.find_element(By.CSS_SELECTOR, ".btn-confirm")
+        ).click()
+        self.wait_for(
+            lambda: self.browser.find_element(By.CSS_SELECTOR, ".gate-slot.filled")
+        )
+        # 3. Fill slots 2–6 directly via ORM
+        room = Room.objects.get(name="Dragon's Den")
+        for i, email in enumerate([
+            "g2@test.io", "g3@test.io", "g4@test.io", "g5@test.io", "g6@test.io"
+        ], start=2):
+            gamer = User.objects.create(email=email)
+            slot = room.gate_slots.get(slot_number=i)
+            slot.gamer = gamer
+            slot.status = GateSlot.FILLED
+            slot.save()
+        room.refresh_from_db()
+        room.gate_status = Room.OPEN
+        room.save()
+        # 4. Gatekeeper disappears via htmx
+        self.wait_for(
+            lambda: self.assertEqual(
+                len(self.browser.find_elements(By.CSS_SELECTOR, ".gate-modal")), 0
+            )
+        )
+
+    def test_owner_can_delete_room_via_gear_menu(self):
+        self.create_pre_authenticated_session("founder@test.io")
+        self.browser.get(self.live_server_url + "/gameboard/")
+        self.wait_for(lambda: self.browser.find_element(By.ID, "id_new_game_name"))
+        self.browser.find_element(By.ID, "id_new_game_name").send_keys("Doomed Room")
+        self.browser.find_element(By.ID, "id_create_game_btn").click()
+        self.wait_for(lambda: self.assertIn("/gate/", self.browser.current_url))
+
+        self.browser.find_element(By.CSS_SELECTOR, ".gear-btn").click()
+        self.wait_for(
+            lambda: self.browser.find_element(By.CSS_SELECTOR, ".btn-danger")
+        ).click()
+
+        self.wait_for(lambda: self.assertEqual(
+            self.browser.current_url, self.live_server_url + "/gameboard/"
+        ))
+        self.assertFalse(Room.objects.filter(name="Doomed Room").exists())
+
+    def test_gatekeeper_overlay_persists_after_htmx_poll(self):
+        # 1. Create room directly (GATHERING) and navigate to its gate URL
+        self.create_pre_authenticated_session("founder@test.io")
+        founder = User.objects.get(email="founder@test.io")
+        room = Room.objects.create(name="Persistent Room", owner=founder)
+        self.browser.get(self.live_server_url + f"/gameboard/room/{room.id}/gate/")
+        # 2. Assert overlay visible on initial page load
+        self.wait_for(
+            lambda: self.browser.find_element(By.CSS_SELECTOR, ".gate-overlay")
+        )
+        # 3. Wait for HTMX poll cycle to fire (poll interval is 3s)
+        time.sleep(4)
+        # 4. Assert overlay still present and visible after poll
+        overlays = self.browser.find_elements(By.CSS_SELECTOR, ".gate-overlay")
+        self.assertEqual(len(overlays), 1)
+        self.assertTrue(overlays[0].is_displayed())
+
+    def test_gamer_can_abandon_room_via_gear_menu(self):
+        founder = User.objects.create(email="founder@test.io")
+        room = Room.objects.create(name="Dragon's Den", owner=founder)
+        slot = room.gate_slots.get(slot_number=2)
+        self.create_pre_authenticated_session("gamer@test.io")
+        gamer, _ = User.objects.get_or_create(email="gamer@test.io")
+        slot.gamer = gamer
+        slot.status = "FILLED"
+        slot.save()
+
+        self.browser.get(self.live_server_url + f"/gameboard/room/{room.id}/gate/")
+
+        self.browser.find_element(By.CSS_SELECTOR, ".gear-btn").click()
+        self.wait_for(
+            lambda: self.browser.find_element(By.CSS_SELECTOR, ".btn-abandon")
+        ).click()
+
+        self.wait_for(lambda: self.assertEqual(
+            self.browser.current_url, self.live_server_url + "/gameboard/"
+        ))
+        slot.refresh_from_db()
+        self.assertEqual(slot.status, "EMPTY")
+        self.assertIsNone(slot.gamer)
+
+
+class CoinSlotTest(FunctionalTest):
+    def setUp(self):
+        super().setUp()
+        Applet.objects.get_or_create(
+            slug="new-game", defaults={"name": "New Game", "context": "gameboard"}
+        )
+        Applet.objects.get_or_create(
+            slug="my-games", defaults={"name": "My Games", "context": "gameboard"}
+        )
+        self.create_pre_authenticated_session("founder@test.io")
+        self.founder = User.objects.get(email="founder@test.io")
+        self.room = Room.objects.create(name="Coin Room", owner=self.founder)
+        self.gate_url = self.live_server_url + f"/gameboard/room/{self.room.id}/gate/"
+
+    def test_coin_slot_active_for_eligible_gamer(self):
+        # Gamer with no slot arrives at gatekeeper — coin slot is active
+        self.browser.get(self.gate_url)
+        self.wait_for(
+            lambda: self.browser.find_element(By.CSS_SELECTOR, ".token-slot.active")
+        )
+        self.browser.find_element(By.CSS_SELECTOR, ".token-insert-btn")
+
+    def test_drop_token_reserves_lowest_empty_slot(self):
+        # Gamer drops token; slot 1 (lowest) becomes reserved with OK button
+        self.browser.get(self.gate_url)
+        self.wait_for(
+            lambda: self.browser.find_element(By.CSS_SELECTOR, ".token-insert-btn")
+        ).click()
+        self.wait_for(
+            lambda: self.browser.find_element(
+                By.CSS_SELECTOR, ".gate-slot[data-slot='1'] .btn-confirm"
+            )
+        )
+        slot = self.room.gate_slots.get(slot_number=1)
+        slot.refresh_from_db()
+        self.assertEqual(slot.status, GateSlot.RESERVED)
+        self.assertEqual(slot.gamer, self.founder)
+
+    def test_confirm_fills_slot_and_removes_ok_button(self):
+        # Drop then confirm → slot 1 FILLED, OK button gone
+        self.browser.get(self.gate_url)
+        self.wait_for(
+            lambda: self.browser.find_element(By.CSS_SELECTOR, ".token-insert-btn")
+        ).click()
+        self.wait_for(
+            lambda: self.browser.find_element(By.CSS_SELECTOR, ".btn-confirm")
+        ).click()
+        self.wait_for(
+            lambda: self.browser.find_element(By.CSS_SELECTOR, ".gate-slot.filled")
+        )
+        self.assertEqual(
+            len(self.browser.find_elements(By.CSS_SELECTOR, ".btn-confirm")), 0
+        )
+        slot = self.room.gate_slots.get(slot_number=1)
+        slot.refresh_from_db()
+        self.assertEqual(slot.status, GateSlot.FILLED)
+
+    def test_gamer_can_reject_pending_token(self):
+        # Drop then reject via Push to Reject → slot remains empty
+        self.browser.get(self.gate_url)
+        self.wait_for(
+            lambda: self.browser.find_element(By.CSS_SELECTOR, ".token-insert-btn")
+        ).click()
+        # Push to Reject appears in coin slot
+        self.wait_for(
+            lambda: self.browser.find_element(By.CSS_SELECTOR, ".token-reject-btn")
+        ).click()
+        # Slot 1 still empty; coin slot active again
+        self.wait_for(
+            lambda: self.browser.find_element(By.CSS_SELECTOR, ".token-slot.active")
+        )
+        slot = self.room.gate_slots.get(slot_number=1)
+        slot.refresh_from_db()
+        self.assertEqual(slot.status, GateSlot.EMPTY)
+
+    def test_coin_slot_locked_while_another_token_is_pending(self):
+        # Pre-set slot 1 as RESERVED by a different user
+        other = User.objects.create(email="other@test.io")
+        slot = self.room.gate_slots.get(slot_number=1)
+        slot.gamer = other
+        slot.status = GateSlot.RESERVED
+        slot.reserved_at = timezone.now()
+        slot.save()
+        # Current user (founder) sees coin slot locked
+        self.browser.get(self.gate_url)
+        self.wait_for(
+            lambda: self.browser.find_element(By.CSS_SELECTOR, ".token-slot.locked")
+        )
+        self.assertEqual(
+            len(self.browser.find_elements(By.CSS_SELECTOR, ".token-insert-btn")), 0
+        )
+
+    def test_last_gamer_sees_pick_roles_button(self):
+        # Fill slots 1–5 via ORM; slot 6 empty
+        for i, email in enumerate([
+            "g1@test.io", "g2@test.io", "g3@test.io", "g4@test.io", "g5@test.io"
+        ], start=1):
+            gamer = User.objects.create(email=email)
+            slot = self.room.gate_slots.get(slot_number=i)
+            slot.gamer = gamer
+            slot.status = GateSlot.FILLED
+            slot.save()
+        # Founder (no slot yet) drops token → gets slot 6
+        self.browser.get(self.gate_url)
+        self.wait_for(
+            lambda: self.browser.find_element(By.CSS_SELECTOR, ".token-insert-btn")
+        ).click()
+        # Slot 6 shows PICK ROLES instead of OK
+        self.wait_for(
+            lambda: self.assertIn(
+                "PICK ROLES",
+                self.browser.find_element(
+                    By.CSS_SELECTOR, ".gate-slot[data-slot='6']"
+                ).text,
+            )
+        )
+        self.assertEqual(
+            len(self.browser.find_elements(By.CSS_SELECTOR, ".btn-confirm")), 0
+        )

src/static_src/scss/_applets.scss

@@ -75,6 +75,7 @@
 #id_dash_applet_menu    { @extend %applet-menu; }
 #id_game_applet_menu    { @extend %applet-menu; }
 #id_wallet_applet_menu  { @extend %applet-menu; }
+#id_room_menu           { @extend %applet-menu; }
 
 // ── Applets grid (shared across all boards) ────────────────
 %applets-grid {

src/static_src/scss/_base.scss

@@ -232,9 +232,13 @@ body {
         .row .col-lg-6 h2 {
             text-align: center;
             text-align-last: center;
-            letter-spacing: 0.25em;
+            letter-spacing: 0.33em;
             margin: 0 0 0.5rem;
             font-size: 2rem;
+
+            &#id_dash_wallet {
+                letter-spacing: 0.25em;
+            }
         }
     }
 }

src/static_src/scss/_button-pad.scss

@@ -90,6 +90,41 @@
             }
     }
 
+    &.btn-abandon {
+        color: rgba(var(--priBl), 1);
+        border-color: rgba(var(--priBl), 1);
+        background-color: rgba(var(--terBl), 1);
+        box-shadow:
+            0.1rem 0.1rem 0.12rem rgba(var(--terBl), 0.25),
+            0.12rem 0.12rem 0.25rem rgba(0, 0, 0, 0.25),
+            0.25rem 0.25rem 0.25rem rgba(var(--terBl), 0.12)
+        ;
+
+        &:hover {
+            text-shadow:
+                0.1rem 0.1rem 0.1rem rgba(0, 0, 0, 0.25),
+                0 0 1rem rgba(var(--priBl), 1)
+                ;
+            box-shadow:
+                0.12rem 0.12rem 0.5rem rgba(0, 0, 0, 0.25),
+                0 0 0.5rem rgba(var(--priBl), 0.12)
+            ;
+        }
+        
+        &:active {
+            border: 0.18rem solid rgba(var(--priBl), 1);
+            text-shadow:
+                -0.1rem -0.1rem 0.25rem rgba(0, 0, 0, 0.25),
+                0 0 0.12rem rgba(var(--priBl), 1)
+            ;
+            box-shadow:
+                -0.1rem -0.1rem 0.12rem rgba(var(--terBl), 0.25),
+                -0.1rem -0.1rem 0.12rem rgba(0, 0, 0, 0.25),
+                0 0 0.5rem rgba(var(--priBl), 0.12)
+            ;
+        }
+    }
+
     &.btn-cancel {
         color: rgba(var(--priOr), 1);
         border-color: rgba(var(--priOr), 1);

src/static_src/scss/_gameboard.scss

@@ -93,6 +93,15 @@ body.page-gameboard {
     }
 }
 
+#id_applet_my_games {
+
+    ul {
+        display: flex;
+        flex-direction: column;
+        
+    }
+}
+
 #id_tooltip_portal {
     position: fixed;
     z-index: 9999;

src/static_src/scss/_room.scss

@@ -0,0 +1,260 @@
+$gate-node: 64px;
+$gate-gap: 36px;
+$gate-line: 2px;
+
+.room-page {
+    position: relative;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    min-height: 60vh;
+}
+
+.room-page .gear-btn,
+#id_room_menu {
+    z-index: 101;
+}
+
+.gate-overlay {
+    position: fixed;
+    inset: 0;
+    display: flex;
+    align-items: center;
+    justify-content: center;
+    background: rgba(0, 0, 0, 0.7);
+    backdrop-filter: blur(4px);
+    z-index: 100;
+}
+
+.gate-modal {
+    display: flex;
+    flex-direction: column;
+    align-items: center;
+    gap: 2rem;
+    padding: 2rem;
+    border-radius: 1rem;
+    background-color: rgba(var(--priUser), 1);
+
+    .gate-header {
+        text-align: center;
+        h1 { margin: 0 0 0.5rem; }
+        .gate-status-wrap {
+            display: flex;
+            justify-content: center;
+            align-items: baseline;
+            opacity: 0.5;
+            font-size: 0.75em;
+            text-transform: uppercase;
+            letter-spacing: 0.15em;
+
+            .status-dots {
+                display: inline-flex;
+                span {
+                    display: inline-block;
+                    width: 0.5em;
+                    text-align: center;
+                }
+            }
+        }
+    }
+
+    .token-slot {
+        position: relative;
+        display: flex;
+        flex-direction: row;
+        border: 2px solid rgba(var(--terUser), 0.7);
+        border-radius: 0.4rem;
+        background: rgba(0, 0, 0, 0.35);
+        min-width: 180px;
+
+        &.locked {
+            opacity: 0.3;
+            pointer-events: none;
+        }
+
+        &.pending,
+        &.claimed {
+            box-shadow:
+                0 0 0.6rem rgba(var(--terUser), 0.5),
+                0 0 1.4rem rgba(var(--terUser), 0.2),
+            ;
+            .token-reject-btn { text-shadow: 0 0 0.5rem rgba(var(--terUser), 0.8); }
+
+            &:hover {
+                border-color: rgba(var(--terUser), 1);
+                background: rgba(0, 0, 0, 0.55);
+                box-shadow:
+                    0 0 0.8rem rgba(var(--terUser), 0.75),
+                    0 0 2rem rgba(var(--terUser), 0.35),
+                ;
+            }
+        }
+
+        .token-rails,
+        button.token-rails {
+            display: flex;
+            flex-direction: row;
+            align-items: stretch;
+            padding: 0.6rem 0.45rem;
+            gap: 0.2rem;
+            border-right: 1px solid rgba(var(--terUser), 0.35);
+
+            .rail {
+                display: block;
+                width: 2px;
+                background: rgba(var(--terUser), 0.55);
+                border-radius: 1px;
+            }
+        }
+
+        button.token-rails {
+            background: transparent;
+            border: none;
+            border-right: 1px solid rgba(var(--terUser), 0.35);
+            cursor: pointer;
+            border-radius: 0.3rem 0 0 0.3rem;
+
+            &:hover {
+                background: rgba(var(--terUser), 0.1);
+                .rail { background: rgba(var(--terUser), 1); }
+            }
+        }
+
+        .token-reject-overlay {
+            position: absolute;
+            inset: 0;
+            background: transparent;
+            border: none;
+            cursor: pointer;
+            border-radius: inherit;
+        }
+
+        .token-panel {
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            justify-content: center;
+            padding: 0.45rem 0.75rem;
+            gap: 0.15rem;
+
+            .token-denomination {
+                font-size: 1.5em;
+                font-weight: bold;
+                color: rgba(var(--terUser), 1);
+                line-height: 1;
+            }
+
+            .token-insert-label,
+            .token-insert-btn {
+                font-size: 0.6em;
+                text-transform: uppercase;
+                letter-spacing: 0.08em;
+                text-align: center;
+                line-height: 1.3;
+            }
+
+            .token-reject-label,
+            .token-reject-btn {
+                font-size: 0.55em;
+                text-transform: uppercase;
+                letter-spacing: 0.06em;
+                opacity: 0.5;
+                line-height: 1.3;
+                text-align: center;
+            }
+
+        }
+    }
+
+    .gate-slots {
+        display: flex;
+        flex-direction: row;
+        align-items: center;
+        gap: $gate-gap;
+
+        .gate-slot {
+            position: relative;
+            width: $gate-node;
+            height: $gate-node;
+            border-radius: 50%;
+            border: $gate-line solid rgba(var(--terUser), 1);
+            display: flex;
+            flex-direction: column;
+            align-items: center;
+            justify-content: center;
+            flex-shrink: 0;
+
+            &.filled,
+            &.reserved {
+                background: rgba(var(--terUser), 0.2);
+            }
+
+            &.filled:hover,
+            &.reserved:hover {
+                box-shadow:
+                    -0.1rem -0.1rem 1rem rgba(var(--ninUser), 1),
+                    -0.1rem -0.1rem 0.25rem rgba(0, 0, 0, 1),
+                    0.05rem 0.05rem 0.5rem rgba(0, 0, 0, 1),
+                ;
+            }
+
+            .slot-number {
+                font-size: 0.7em;
+                opacity: 0.5;
+            }
+
+            .slot-gamer { display: none; }
+
+            form {
+                position: absolute;
+                inset: 0;
+                display: flex;
+                align-items: center;
+                justify-content: center;
+            }
+
+            .drop-token-btn {
+                position: absolute;
+                inset: 0;
+                border-radius: 50%;
+                width: 100%;
+                height: 100%;
+                background: transparent;
+                border: none;
+                box-shadow:
+                    0.05rem 0.05rem 0.5rem rgba(0, 0, 0, 1),
+                ;
+                font-size: 0;
+                cursor: pointer;
+
+                &:hover {
+                    background: rgba(var(--quaUser), 0.15);
+                    box-shadow:
+                        -0.1rem -0.1rem 1rem rgba(var(--ninUser), 1),
+                        -0.1rem -0.1rem 0.25rem rgba(0, 0, 0, 1),
+                        0.05rem 0.05rem 0.5rem rgba(0, 0, 0, 1),
+                    ;
+                }
+            }
+        }
+    }
+}
+
+// Mobile: 2×3 grid, both rows left-to-right
+@media (max-width: 550px) {
+    .gate-modal .gate-slots {
+        display: grid;
+        grid-template-columns: repeat(3, $gate-node);
+        grid-template-rows: repeat(2, $gate-node);
+        gap: $gate-gap;
+
+        .gate-slot {
+            &:nth-child(1) { grid-column: 1; grid-row: 1; }
+            &:nth-child(2) { grid-column: 2; grid-row: 1; }
+            &:nth-child(3) { grid-column: 3; grid-row: 1; }
+            &:nth-child(4) { grid-column: 1; grid-row: 2; }
+            &:nth-child(5) { grid-column: 2; grid-row: 2; }
+            &:nth-child(6) { grid-column: 3; grid-row: 2; }
+        }
+    }
+}

src/static_src/scss/core.scss

@@ -5,6 +5,7 @@
 @import 'dashboard';
 @import 'gameboard';
 @import 'palette-picker';
+@import 'room';
 @import 'wallet-tokens';
 
 

src/templates/apps/gameboard/_partials/_applet-my-games.html

@@ -4,6 +4,10 @@
 >
     <h2>My Games</h2>
     <ul class="game-list">
-        <small>[feature forthcoming]</small>
+        {% for room in my_games %}
+            <li><a href="{% url 'epic:gatekeeper' room.id %}">{{ room.name }}</a></li>
+        {% empty %}
+            <li class="game-list-item"><small>No games yet</small></li>
+        {% endfor %}
     </ul>
 </section>

src/templates/apps/gameboard/_partials/_applet-new-game.html

@@ -3,7 +3,9 @@
     style="--applet-cols: {{ entry.applet.grid_cols }}; --applet-rows: {{ entry.applet.grid_rows }};"
 >
     <h2>New Game</h2>
-    <ul class="game-type">
+    <form method="POST" action="{% url "epic:create_room" %}" style="display:flex; gap:0.5rem; align-items:center;">
-        <small>[feature forthcoming]</small>
+        {% csrf_token %}
-    </ul>
+        <input id="id_new_game_name" name="name" type="text" placeholder="Room name" class="form-control form-control-lg" style="flex:1; min-width:0;" />
+        <button type="submit" id="id_create_game_btn" class="btn btn-confirm">OK</button>
+    </form>
 </section>

src/templates/apps/gameboard/_partials/_gatekeeper.html

@@ -0,0 +1,98 @@
+<div
+    id="id_gate_wrapper"
+    hx-get="{% url 'epic:gate_status' room.id %}"
+    hx-trigger="every 3s"
+    hx-swap="outerHTML"
+>
+    <div class="gate-overlay">
+        <div class="gate-modal" role="dialog" aria-label="Gatekeeper">
+
+            <header class="gate-header">
+                <h1>{{ room.name }}</h1>
+                <div class="gate-status-wrap">
+                    <span class="gate-status-text">{{ room.get_gate_status_display }}</span>
+                    <span class="status-dots" aria-hidden="true">
+                        <span></span><span></span><span></span><span></span>
+                    </span>
+                </div>
+            </header>
+
+            <div class="token-slot{% if can_drop %} active{% elif user_reserved_slot %} pending{% elif user_filled_slot %} claimed{% else %} locked{% endif %}">
+                {% if can_drop %}
+                    <form method="POST" action="{% url 'epic:drop_token' room.id %}" style="display:contents">
+                        {% csrf_token %}
+                        <button type="submit" class="token-rails" aria-label="Insert token to play">
+                            <span class="rail"></span>
+                            <span class="rail"></span>
+                        </button>
+                    </form>
+                {% else %}
+                    <div class="token-rails">
+                        <span class="rail"></span>
+                        <span class="rail"></span>
+                    </div>
+                {% endif %}
+                <div class="token-panel">
+                    <div class="token-denomination">1</div>
+                    <span class="token-insert-label">INSERT TOKEN TO PLAY</span>
+                    <span class="token-reject-label">PUSH TO REJECT</span>
+                </div>
+                {% if user_can_reject %}
+                    <form method="POST" action="{% url 'epic:reject_token' room.id %}" style="display:contents">
+                        {% csrf_token %}
+                        <button type="submit" class="token-reject-overlay" aria-label="Push to reject"></button>
+                    </form>
+                {% endif %}
+            </div>
+
+            <div class="gate-slots">
+                {% for slot in slots %}
+                    <div
+                        class="gate-slot{% if slot.status == 'EMPTY' %} empty{% elif slot.status == 'FILLED' %} filled{% elif slot.status == 'RESERVED' %} reserved{% endif %}"
+                        data-slot="{{ slot.slot_number }}"
+                    >
+                        <span class="slot-number">{{ slot.slot_number }}</span>
+                        {% if slot.gamer %}
+                            <span class="slot-gamer">{{ slot.gamer.email }}</span>
+                        {% else %}
+                            <span class="slot-gamer">empty</span>
+                        {% endif %}
+                        {% if slot.status == 'RESERVED' and slot.gamer == request.user %}
+                            <form method="POST" action="{% url 'epic:confirm_token' room.id %}">
+                                {% csrf_token %}
+                                {% if is_last_slot %}
+                                    <button type="submit" class="btn btn-primary btn-xl">PICK ROLES</button>
+                                {% else %}
+                                    <button type="submit" class="btn btn-confirm">OK</button>
+                                {% endif %}
+                            </form>
+                        {% endif %}
+                    </div>
+                {% endfor %}
+            </div>
+
+            {% if request.user == room.owner %}
+                <form method="POST" action="{% url 'epic:invite_gamer' room.id %}">
+                    {% csrf_token %}
+                    <input type="email" name="invitee_email" id="id_invite_email" placeholder="friend@example.com">
+                    <button type="submit" id="id_invite_btn" class="btn btn-primary btn-xl">Invite</button>
+                </form>
+            {% endif %}
+
+        </div>
+    </div>
+</div>
+<script>
+    (function () {
+        clearInterval(window._gateDots);
+        var wrap = document.querySelector('.status-dots');
+        if (!wrap) return;
+        var dots = wrap.querySelectorAll('span');
+        var n = 0;
+        window._gateDots = setInterval(function () {
+            if (!document.contains(wrap)) { clearInterval(window._gateDots); return; }
+            dots.forEach(function (d, i) { d.textContent = i < n ? '.' : ''; });
+            n = (n + 1) % 5;
+        }, 400);
+    }());
+</script>

src/templates/apps/gameboard/_partials/_room_gear.html

@@ -0,0 +1,16 @@
+{% include "apps/applets/_partials/_gear.html" with menu_id="id_room_menu" %}
+
+<div id="id_room_menu" style="display:none">
+    <a href="/gameboard/" class="btn btn-cancel">EXIT</a>
+    {% if request.user == room.owner %}
+    <form method="POST" action="{% url 'epic:delete_room' room.id %}">
+        {% csrf_token %}
+        <button type="submit" class="btn btn-danger">DEL</button>
+    </form>
+    {% else %}
+    <form method="POST" action="{% url 'epic:abandon_room' room.id %}">
+        {% csrf_token %}
+        <button type="submit" class="btn btn-abandon">BYE</button>
+    </form>
+    {% endif %}
+</div>

src/templates/apps/gameboard/room.html

@@ -0,0 +1,18 @@
+{% extends "core/base.html" %}
+
+{% block title_text %}Gameboard{% endblock title_text %}
+{% block header_text %}<span>Game</span>room{% endblock header_text %}
+
+{% block content %}
+    <div class="room-page">
+        <div class="room-shell">
+            {% comment "game room content" %}gaussian blur + darkening (cf., e.g., tooltip effect) {% endcomment %}
+            <div class="room-table"></div>
+        </div>
+
+        {% if room.gate_status == "GATHERING" %}
+            {% include "apps/gameboard/_partials/_gatekeeper.html" %}
+        {% endif %}
+        {% include "apps/gameboard/_partials/_room_gear.html" %}
+    </div>
+{% endblock content %}