Polish demo: boss reveal screen, portraits, varied packs, paced draft, title copy

- Boss reveal screen before rules: full splash art + "Your Enemy" + villain name
and quote (The Hollow Warden / Specter-9 / The Necrolich); battle board shows
face-cropped player vs boss portraits.
- Draft pacing: minimum loading window per pick (uniform "forging" beat), prefetch
all branches so any pick is ready, reveal first pack the moment it is ready.
- Card variety: rotate per-slot effect focus per pack, and fall back to the slot
focus (not always deal) so name-rejected packs still show varied effects.
- Name filter bans the leaked word "primitive".
- Title screen: tighter cohesive layout + model-stack pitch copy.
- README: Build Small submission section, tags, model stack.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>

README.md

@@ -13,8 +13,13 @@ tags:
   - thousand-token-wood
   - off-brand
   - tiny-titan
+  - best-demo
+  - best-agent
+  - bonus-quest-champion
   - minicpm
   - nemotron
+  - modal
+  - codex
 models:
   - openbmb/MiniCPM-V-4
   - nvidia/Nemotron-Mini-4B-Instruct
@@ -29,6 +34,26 @@ You name a challenger, choose a world, choose a school of magic, draft a 15-card
 
 The engine keeps the game fair. The model invents the card identity; deterministic Python code prices and resolves the card mechanics.
 
+## Build Small Submission
+
+Track: **Thousand Token Wood**.
+
+Targeted prizes and badges:
+
+- **Best MiniCPM Build:** MiniCPM authors the generated draft cards.
+- **Nemotron Hardware Prize:** Nemotron drives the autonomous boss player.
+- **Best Use of Modal:** the submitted Space calls Modal GPU endpoints for model inference.
+- **Best Use of Codex:** Codex was used during development, with the project connected through the repo/Space workflow.
+- **Off Brand:** Tabras uses a custom Gradio interface rather than the default Gradio look.
+- **Tiny Titan:** the submitted runtime uses models in the 4B-and-under class.
+- **Best Agent:** the boss is an agentic Nemotron player that observes public duel state, selects playable card indexes through a constrained JSON action schema, and executes actions inside the deterministic game engine.
+- **Best Demo:** demo video and social post links are listed below.
+- **Bonus Quest Champion:** Tabras combines multiple sponsor criteria and bonus badges in one submission.
+
+Demo video: **TODO: add public demo link before submission deadline.**
+
+Social post: https://x.com/yewzoid/status/2066647997740691678?s=20
+
 ## What Makes It AI-Native
 
 - **MiniCPM authors draft cards.** It proposes card concepts, names, flavor text, and effect shapes for the current deck.
@@ -56,16 +81,18 @@ That split is the core design: AI provides surprise and taste, while the engine
 
 ## Model Stack
 
-All listed models are under the hackathon's 32B parameter limit.
+All listed models are under the hackathon's 32B parameter limit. The submitted configuration uses models in the 4B-and-under class for Tiny Titan consideration.
 
-| Role | Default model | Use |
-| --- | --- | --- |
-| Card author | `openbmb/MiniCPM-V-4` | Draft pack text and card concepts |
-| Boss AI | `nvidia/Nemotron-Mini-4B-Instruct` | Enemy play decisions |
-| Art | `stabilityai/sdxl-turbo` | Fast card illustration |
+| Role | Default model | Size class | Use |
+| --- | --- | --- | --- |
+| Card author | `openbmb/MiniCPM-V-4` | 4B-and-under class | Draft pack text and card concepts |
+| Boss agent | `nvidia/Nemotron-Mini-4B-Instruct` | 4B | Enemy play decisions |
+| Art | `stabilityai/sdxl-turbo` | 4B-and-under class | Fast card illustration |
 
 The Hugging Face Space entry point is [app_hf.py](app_hf.py). The Space is a thin client: MiniCPM (cards), Nemotron (boss), and SDXL-Turbo (art) run on dedicated Modal GPU endpoints (see [modal_app.py](modal_app.py)), which the Space calls over HTTP. This keeps heavy compute off the Space (free CPU hardware) and gives each model its own autoscaled GPU.
 
+Tabras also runs locally. By default, [app.py](app.py) can launch without model servers and use deterministic fallback generation. For local AI, [launch_ai.py](launch_ai.py) starts a local MiniCPM llama.cpp server, and the runtime can use local Transformers, MLX, and Diffusers backends through environment variables.
+
 ## Running Locally
 
 Install dependencies:

app.py

@@ -15,10 +15,12 @@ from ui import (
     HAND_PANEL_COUNT,
     RunState,
     board_html,
+    boss_splash_uri,
     choose_draft_card_loading_steps,
     collect_ready_battle,
     collect_ready_pack,
     draft_screen_html,
+    escape_html,
     log_html,
     new_run_shell,
     pass_turn_steps,
@@ -127,19 +129,33 @@ button.primary {
 }
 
 .tabras-title {
-  min-height: 70vh;
   display: flex;
   flex-direction: column;
   justify-content: center;
   align-items: center;
   text-align: center;
+  gap: 26px;
+  padding: 18vh 20px 0;
 }
 .tabras-title h1 {
-  font-size: 76px;
-  margin: 0 0 12px;
+  font-size: 92px;
+  margin: 0;
   color: #f6f0ff;
   text-shadow: 0 0 30px rgba(160, 90, 255, 0.6), 0 3px 18px rgba(0, 0, 0, 0.65);
 }
+.tabras-sub {
+  display: flex;
+  flex-direction: column;
+  gap: 10px;
+  color: #efe6ff;
+  text-shadow: 0 2px 10px rgba(0, 0, 0, 0.8);
+}
+.tabras-sub .subline {
+  font-size: 21px;
+  line-height: 1.4;
+  white-space: nowrap;
+}
+#play-now-btn { margin-top: 26px !important; }
 .gradio-container .setup-panel {
   background: rgba(26, 20, 46, 0.82) !important;
   border: 2px solid rgba(190, 160, 255, 0.3) !important;
@@ -436,6 +452,85 @@ button.primary {
   font-size: 16px;
   line-height: 1.45;
 }
+.reveal-screen {
+  min-height: 64vh;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  gap: 12px;
+  padding-top: 12px;
+  text-align: center;
+  animation: reveal-in 0.6s ease backwards;
+}
+#reveal-next-btn {
+  width: auto !important;
+  min-width: 150px !important;
+  max-width: 200px !important;
+  align-self: center !important;
+  margin: 4px auto 0 !important;
+}
+#reveal-next-btn button {
+  width: auto !important;
+  min-width: 150px !important;
+  padding: 9px 26px !important;
+}
+@keyframes reveal-in { from { opacity: 0; transform: scale(0.97); } to { opacity: 1; transform: none; } }
+.reveal-kicker {
+  font-size: 15px;
+  font-weight: 900;
+  letter-spacing: 0.22em;
+  text-transform: uppercase;
+  color: #f06bff;
+  text-shadow: 0 0 18px rgba(232, 91, 255, 0.55);
+}
+.reveal-art {
+  width: min(440px, 86vw);
+  height: min(440px, 60vh);
+  border-radius: 16px;
+  border: 3px solid #b14ad0;
+  background-size: cover;
+  background-position: center top;
+  background-color: #160e26;
+  box-shadow: 0 0 48px rgba(177, 74, 208, 0.45), 0 24px 60px rgba(0, 0, 0, 0.6);
+}
+.reveal-name {
+  font-size: 40px;
+  font-weight: 900;
+  color: #f6f0ff;
+  letter-spacing: 0.04em;
+  text-shadow: 0 0 26px rgba(232, 91, 255, 0.5), 0 3px 12px rgba(0, 0, 0, 0.7);
+}
+.reveal-quote {
+  font-size: 19px;
+  font-style: italic;
+  color: #d9c4ee;
+  max-width: 540px;
+}
+.versus {
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  gap: 28px;
+  margin: 6px 0 14px;
+}
+.versus-side { display: flex; flex-direction: column; align-items: center; gap: 6px; }
+.versus-face {
+  width: 132px;
+  height: 132px;
+  border-radius: 50% 50% 46% 46%;
+  border: 4px solid #b08a4f;
+  background-size: cover;
+  background-position: center top;
+  background-color: #1b1430;
+  box-shadow: 0 12px 30px rgba(0, 0, 0, 0.55);
+}
+.versus-side:last-child .versus-face { border-color: #b14ad0; box-shadow: 0 0 26px rgba(232, 91, 255, 0.4), 0 12px 30px rgba(0, 0, 0, 0.55); }
+.versus-face-text { display: flex; align-items: center; justify-content: center; color: #f4d69b; font-weight: 900; font-size: 22px; }
+.versus-name { font-weight: 800; color: #f6f0ff; font-size: 18px; }
+.versus-tag { font-size: 12px; color: #b9a8e0; letter-spacing: 0.04em; }
+.versus-vs { font-size: 30px; font-weight: 900; color: #ffd35c; text-shadow: 0 0 16px rgba(255, 211, 92, 0.5); }
+.villain-story { text-align: center; color: #d9d0f0; font-style: italic; max-width: 540px; margin: 0 auto; }
 .rules-grid {
   display: grid;
   grid-template-columns: repeat(2, minmax(0, 1fr));
@@ -531,6 +626,10 @@ button.primary {
   color: #f4d69b;
   box-shadow: 0 10px 26px rgba(0, 0, 0, 0.5);
 }
+.hero-face.portrait {
+  background-size: cover;
+  background-position: center top;
+}
 .hp-gem, .block-gem, .ward-gem {
   position: absolute;
   width: 42px;
@@ -852,7 +951,14 @@ def build_app() -> gr.Blocks:
         screen_state = gr.State("title")
 
         with gr.Group(visible=True, elem_id="title-screen") as title_group:
-            gr.HTML("<div class='tabras-title'><h1>Tabras</h1><p>A small-model card duel on an old wooden desk.</p></div>")
+            gr.HTML(
+                "<div class='tabras-title'><h1>Tabras</h1>"
+                "<div class='tabras-sub'>"
+                "<div class='subline'>You're a spellcaster fighting an evil wizard.</div>"
+                "<div class='subline'>Draft your spellbook by selecting nine cards that are authored by MiniCPM and drawn by SDXL-Turbo.</div>"
+                "<div class='subline'>Are you powerful enough to destroy the Nemotron-enhanced wizard?</div>"
+                "</div></div>"
+            )
             play_now = gr.Button("Play Now", variant="primary", elem_id="play-now-btn")
 
         with gr.Group(visible=False, elem_id="name-screen") as name_group:
@@ -871,6 +977,10 @@ def build_app() -> gr.Blocks:
                 gr.HTML("<div class='step-kicker'>Step 2 of 3</div><h2>Choose your background</h2>")
             gr.HTML(background_selector_html())
 
+        with gr.Group(visible=False, elem_id="reveal-screen") as reveal_group:
+            reveal_view = gr.HTML()
+            reveal_next = gr.Button("Continue", variant="primary", elem_id="reveal-next-btn")
+
         with gr.Group(visible=False, elem_id="rules-screen") as rules_group:
             rules_view = gr.HTML()
             continue_rules = gr.Button("Start Draft", variant="primary", elem_id="start-draft-btn")
@@ -902,9 +1012,11 @@ def build_app() -> gr.Blocks:
             name_group,
             school_group,
             background_group,
+            reveal_group,
             rules_group,
             draft_group,
             battle_group,
+            reveal_view,
             rules_view,
             draft_view,
             board_view,
@@ -919,6 +1031,7 @@ def build_app() -> gr.Blocks:
             button.click(value_handler(choose_background, value), outputs=outputs)
         for value, button in zip(("fire", "ice", "earth"), school_buttons):
             button.click(value_handler(choose_school, value), inputs=[name, world_state], outputs=outputs)
+        reveal_next.click(show_rules, inputs=[state], outputs=outputs)
         continue_rules.click(show_draft_from_rules, inputs=[state], outputs=outputs)
         for index, button in enumerate(draft_buttons):
             button.click(indexed_handler(draft_pick, index), inputs=[state], outputs=outputs)
@@ -997,13 +1110,21 @@ def choose_school(school: str, name: str, world: str) -> list[object]:
     return start_rules(name, school, world)
 
 
-# Start deck generation while the rules screen is shown.
+# Reveal the boss, then start deck generation in the background. The reveal +
+# rules screens give the first pack time to forge before the draft.
 def start_rules(name: str, school: str, world: str) -> list[object]:
     client = card_client_from_env()
     art_client = art_client_from_env()
     run_state = new_run_shell(name, world, school_as_literal(school), seed=Random().getrandbits(32))
     run_state = queue_next_pack(run_state, client, art_client)
-    return render(run_state, "rules")
+    return render(run_state, "reveal")
+
+
+# Move from the boss reveal to the rules screen.
+def show_rules(run_state: RunState | None) -> list[object]:
+    if run_state is None:
+        return render(None, "name")
+    return render(refresh_art(run_state), "rules")
 
 
 # Move from rules to draft, showing deck loading if the first pack is not ready.
@@ -1044,9 +1165,9 @@ def end_player_turn(run_state: RunState | None):
 
 # Refresh visible generated art without advancing the game.
 def refresh_screen(run_state: RunState | None, screen: str, world: str = "Dark Fantasy") -> list[object]:
-    if screen not in {"title", "name", "school", "background", "rules", "draft", "battle"}:
+    if screen not in {"title", "name", "school", "background", "reveal", "rules", "draft", "battle"}:
         screen = "title"
-    if screen in {"rules", "draft"}:
+    if screen in {"reveal", "rules", "draft"}:
         client, art_client = card_client_from_env(), art_client_from_env()
         run_state = collect_ready_pack(refresh_art(run_state), client, art_client)
         run_state = collect_ready_battle(run_state, client, art_client)
@@ -1087,9 +1208,11 @@ def render(run_state: RunState | None, screen: str, world: str = "Dark Fantasy")
         gr.update(visible=screen == "name"),
         gr.update(visible=screen == "school"),
         gr.update(visible=screen == "background"),
+        gr.update(visible=screen == "reveal"),
         gr.update(visible=screen == "rules"),
         gr.update(visible=screen == "draft"),
         gr.update(visible=screen == "battle"),
+        reveal_html(run_state),
         rules_html(run_state),
         draft_screen_html(run_state),
         board_html(run_state),
@@ -1177,18 +1300,49 @@ def selector_card(button_id: str, label: str, copy: str, image: str, dark: str,
 
 
 # Return the dedicated rules screen while deck generation runs.
+# Villain name + in-character quote per world, shown on the boss reveal screen.
+VILLAINS: dict[str, tuple[str, str]] = {
+    "dark fantasy": ("The Hollow Warden", "“The keep has not opened its gates in an age. It will not open for you.”"),
+    "cyberpunk": ("Specter-9", "“Your magic is a legacy format. I am the patch that deprecates it.”"),
+    "anime": ("The Necrolich", "“I have waited aeons to rule this world. You will not stop me.”"),
+}
+
+
+# Return the dramatic boss reveal: full art, villain name, and a quote.
+def reveal_html(run_state: RunState | None) -> str:
+    if run_state is None:
+        return ""
+    world = run_state.world
+    villain_name, quote = VILLAINS.get(world.strip().lower(), VILLAINS["dark fantasy"])
+    splash = boss_splash_uri(world)
+    art = (
+        f"<div class='reveal-art' style=\"background-image:url('{splash}')\"></div>"
+        if splash
+        else "<div class='reveal-art reveal-art-empty'></div>"
+    )
+    return (
+        "<div class='reveal-screen'>"
+        "<div class='reveal-kicker'>Your Enemy</div>"
+        f"{art}"
+        f"<div class='reveal-name'>{escape_html(villain_name)}</div>"
+        f"<div class='reveal-quote'>{escape_html(quote)}</div>"
+        "</div>"
+    )
+
+
 def rules_html(run_state: RunState | None) -> str:
     if run_state is None:
         return ""
     return (
         "<div class='rules-screen'><div class='rules-card'>"
-        "<h1>Rules</h1>"
-        "<p>Build a 15-card deck, then duel the boss across paired rounds.</p>"
+        "<h1>The Rules</h1>"
         "<div class='rules-grid'>"
-        "<div class='rule-tile'><b>Energy</b><span>Your energy resets each round. It does not carry over.</span></div>"
-        "<div class='rule-tile'><b>Drafting</b><span>Pick one card from each pack. Anchor picks set the deck's direction.</span></div>"
-        "<div class='rule-tile'><b>Defense</b><span>Block lasts until your next turn. Ward absorbs one future hit.</span></div>"
-        "<div class='rule-tile'><b>Boss</b><span>The boss reads the public board, then plays from its hidden hand.</span></div>"
+        "<div class='rule-tile'><b>Each round</b><span>A coin flip decides who acts first &mdash; knowing the order is a weapon.</span></div>"
+        "<div class='rule-tile'><b>Energy</b><span>Start at 1, ramp to 5. It refills every round and never carries over.</span></div>"
+        "<div class='rule-tile'><b>Block</b><span>Stops incoming damage until your next turn, then fades.</span></div>"
+        "<div class='rule-tile'><b>Ward</b><span>A persistent shield that absorbs one decisive hit, whenever it lands.</span></div>"
+        "<div class='rule-tile'><b>Draft</b><span>Pick one card from each pack to build a 15-card deck.</span></div>"
+        "<div class='rule-tile'><b>Win</b><span>Reduce the boss to 0 HP across the duel.</span></div>"
         "</div>"
         "</div></div>"
     )

generator.py

@@ -1,5 +1,6 @@
 from dataclasses import dataclass
 import json
+import random
 import subprocess
 import tempfile
 from collections import Counter
@@ -301,8 +302,9 @@ NAME_BAN = (
     "anime",
     "fantasy",
     "spell",
+    "primitive",
 )
-NAME_STEM_BAN = ("burn", "fast", "flam", "pressur")
+NAME_STEM_BAN = ("burn", "fast", "flam", "pressur", "primitiv")
 # Deep per-school name pools so a duplicate is replaced with a fresh evocative
 # name (drawn in order against the run's used-name set) instead of a number.
 FALLBACK_NAMES: dict[str, tuple[str, ...]] = {
@@ -411,7 +413,12 @@ def generate_llamacpp_card(chat: ChatCompleter, payload: dict[str, Any], pack_ca
     if card_acceptable(card, need, payload):
         return card
     retry = parse_llamacpp_card_text(chat.complete(card_system_prompt(), llamacpp_retry_prompt(payload, need)), payload, pack_cards, discard_bad_text=False)
-    return retry if card_acceptable(retry, need, payload) else repair_llamacpp_card(fallback_raw_for_need(need, payload), payload, pack_cards)
+    if card_acceptable(retry, need, payload):
+        return retry
+    # Fall back to this slot's focus primitive (not always deal) so a pack whose
+    # names get rejected still shows varied effects instead of three identical cards.
+    fallback_need = f"explore primitive_id {focus}" if focus else need
+    return repair_llamacpp_card(fallback_raw_for_need(fallback_need, payload), payload, pack_cards)
 
 
 # Return whether a generated card meets its need with a non-generic name.
@@ -818,7 +825,10 @@ def pack_focuses(payload: dict[str, Any], size: int) -> list[str]:
     allowed = list(payload.get("allowed_primitives", []))
     if not allowed:
         return [""] * size
-    return [str(allowed[index % len(allowed)]) for index in range(size)]
+    # Rotate the focus window by a random offset each pack so packs differ from
+    # one another (not always deal/burn/bomb), while staying distinct within a pack.
+    start = random.randrange(len(allowed))
+    return [str(allowed[(start + index) % len(allowed)]) for index in range(size)]
 
 
 # Give every pick in a parallel-built pack a distinct name from the school pool.

tests/test_app.py

@@ -104,12 +104,12 @@ def test_start_rules_queues_deck_generation(monkeypatch) -> None:
     output = start_rules("Ada", "ice", "Anime")
     state = output[0]
 
-    assert output[1] == "rules"
+    # start_rules now lands on the boss reveal screen (rules follow on Continue).
+    assert output[1] == "reveal"
     assert state.player_name == "Ada"
     assert state.school == "ice"
-    assert "Rules" in output[9]
-    assert "Preparing your deck" not in output[9]
-    assert "First draft pack ready" not in output[9]
+    assert "reveal-screen" in output[10]
+    assert "The Necrolich" in output[10]
 
     forge.drain()
     refresh_screen(state, "rules")
@@ -118,6 +118,7 @@ def test_start_rules_queues_deck_generation(monkeypatch) -> None:
 
 # Verify the rules screen starts image work once card text is ready.
 def test_rules_screen_starts_art_generation(monkeypatch) -> None:
+    monkeypatch.setattr("ui.MIN_DRAFT_LOADING_SECONDS", 0.0)
     forge.reset()
     client = AppPackClient()
     art_client = AppArtClient()
@@ -144,4 +145,4 @@ def test_skip_rules_shows_loading_deck(monkeypatch) -> None:
 
     assert output[1] == "draft"
     assert output[0].loading == "Loading your deck"
-    assert "Loading your deck" in output[10]
+    assert "Loading your deck" in output[12]

tests/test_ui.py

@@ -102,7 +102,8 @@ def test_queue_next_pack_shows_loading() -> None:
 
 
 # Verify a ready background pack replaces the loading state.
-def test_collect_ready_pack_installs_pack() -> None:
+def test_collect_ready_pack_installs_pack(monkeypatch) -> None:
+    monkeypatch.setattr("ui.MIN_DRAFT_LOADING_SECONDS", 0.0)
     forge.reset()
     client = ForgePackClient()
     state = queue_next_pack(new_run_shell("Ada", "anime", "ice", seed=1), client)
@@ -116,7 +117,8 @@ def test_collect_ready_pack_installs_pack() -> None:
 
 
 # Verify draft packs reveal text before queued art settles.
-def test_collect_ready_pack_reveals_before_art() -> None:
+def test_collect_ready_pack_reveals_before_art(monkeypatch) -> None:
+    monkeypatch.setattr("ui.MIN_DRAFT_LOADING_SECONDS", 0.0)
     forge.reset()
     client = ForgePackClient()
     art_client = GatedArtClient()
@@ -487,9 +489,9 @@ def test_new_run_warms_forge(monkeypatch) -> None:
     client = ForgePackClient()
     state = new_run("Ada", "anime", "ice", client, seed=3)
     forge.drain()
-    # pack 1 + one speculative next pack; the boss deck is deferred (draft_step >= 2)
-    # so it no longer competes with the first visible pack.
-    assert client.calls == 2
+    # pack 1 + three speculative branch packs (one per visible card); the boss deck
+    # is deferred (draft_step >= 2) so it never competes with the first pack.
+    assert client.calls == 4
     picked = choose_draft_card(state, 0, client)
     assert all(card.name.startswith("Forged") for card in picked.current_pack)
 
@@ -499,7 +501,7 @@ def test_prefetch_pack_limit_env(monkeypatch) -> None:
     monkeypatch.setenv("TABRAS_PREFETCH_PACKS", "0")
     assert prefetch_pack_limit() == 0
     monkeypatch.setenv("TABRAS_PREFETCH_PACKS", "bad")
-    assert prefetch_pack_limit() == 1
+    assert prefetch_pack_limit() == CARD_PANEL_COUNT
 
 
 # Verify battle start consumes the pre-forged boss deck.

ui.py

@@ -1,6 +1,9 @@
+import base64
+import time
 from collections.abc import Callable, Iterator
 from dataclasses import dataclass, replace
 import os
+from pathlib import Path
 from random import Random
 import sys
 from typing import Sequence
@@ -19,6 +22,12 @@ from primitives import School
 CARD_PANEL_COUNT = 3
 HAND_PANEL_COUNT = 10
 THEME = "dark fantasy"
+# Minimum draft loading-screen window: every pick shows the same brief "forging"
+# beat, which also absorbs any pack that is not prefetched yet. Tunable via env.
+try:
+    MIN_DRAFT_LOADING_SECONDS = float(os.environ.get("TABRAS_MIN_DRAFT_LOADING", "2.0"))
+except ValueError:
+    MIN_DRAFT_LOADING_SECONDS = 2.0
 
 
 @dataclass(frozen=True)
@@ -47,6 +56,7 @@ class RunState:
     boss_thought: str = ""
     pack_fading: int = -1
     loading: str = ""
+    loading_since: float = 0.0
 
 
 Steps = Iterator[RunState]
@@ -129,7 +139,7 @@ def queue_next_pack(
         return state
     cost = SYNERGY_COSTS[state.draft_order[state.draft_step]]
     forge.submit(pack_key(state), pack_maker(client, art_client, state, cost))
-    return replace(state, current_pack=(), loading=loading_message(state))
+    return replace(state, current_pack=(), loading=loading_message(state), loading_since=time.monotonic())
 
 
 # Attach a queued draft pack once its background job finishes.
@@ -145,6 +155,11 @@ def collect_ready_pack(
     if pack is None:
         forge.submit(pack_key(state), pack_maker(client, art_client, state, cost))
         return state
+    # Hold the loading beat for a minimum window so every draft transition looks
+    # the same (a deliberate "forging" pause) instead of some snapping in instantly
+    # and some lagging; the prefetched pack is already done well within it.
+    if state.loading_since and time.monotonic() - state.loading_since < MIN_DRAFT_LOADING_SECONDS:
+        return state
     pack = dedupe_pack_against_deck(pack, state.player_deck)
     warm_card_art(art_client, pack)
     pack = collect_ready_cards(pack)
@@ -298,9 +313,11 @@ def prefetch_next_packs(state: RunState, client: CardPackClient | None, art_clie
 # Return how many possible next draft branches to forge speculatively.
 def prefetch_pack_limit() -> int:
     try:
-        return max(0, int(os.environ.get("TABRAS_PREFETCH_PACKS", "1")))
+        # Prefetch every branch (one per visible card) so whichever card the
+        # player picks, its next pack is already forging in the background.
+        return max(0, int(os.environ.get("TABRAS_PREFETCH_PACKS", str(CARD_PANEL_COUNT))))
     except ValueError:
-        return 1
+        return CARD_PANEL_COUNT
 
 
 # Return the forge key for the boss deck of one run.
@@ -913,7 +930,7 @@ def enemy_zone_html(state: RunState) -> str:
     thinking = f"<div class='boss-thinking'>{escape_html(thought)}</div>" if state.boss_thinking else ""
     return (
         "<div class='zone enemy-zone'>"
-        f"<div class='zone-center'>{enemy_hand_html(enemy)}{hero_html(enemy, state.enemy_school, 'Boss', True, state.hp_flash[1])}{thinking}</div>"
+        f"<div class='zone-center'>{enemy_hand_html(enemy)}{hero_html(enemy, state.enemy_school, 'Boss', True, state.hp_flash[1], boss_portrait_uri(state.world))}{thinking}</div>"
         f"{piles_html(enemy)}"
         "</div>"
     )
@@ -926,7 +943,7 @@ def player_zone_html(state: RunState) -> str:
     return (
         "<div class='zone player-zone'>"
         "<div class='zone-center'>"
-        f"{hero_html(player, state.school, state.player_name, False, state.hp_flash[0])}"
+        f"{hero_html(player, state.school, state.player_name, False, state.hp_flash[0], player_portrait_uri(state.world, state.school))}"
         f"{mana_html(player, state.duel.round_number)}"
         f"{hand_fan_html(player)}"
         "</div>"
@@ -988,15 +1005,62 @@ def round_splash_html(state: RunState) -> str:
     )
 
 
+# Cached portrait thumbnails (small JPEGs) keyed by asset stem, embedded as data
+# URIs so the board can re-render each timer tick without streaming the big PNGs.
+_THUMBS = Path(__file__).parent / "assets" / "thumbs"
+_portrait_cache: dict[str, str] = {}
+_WORLD_PREFIX = {"dark fantasy": "darkFantasy", "cyberpunk": "cyberpunk", "anime": "anime"}
+
+
+# Return a thumbnail data URI for an asset stem, or "" if it is missing.
+def thumb_uri(stem: str) -> str:
+    if stem not in _portrait_cache:
+        path = _THUMBS / f"{stem}.jpg"
+        _portrait_cache[stem] = (
+            "data:image/jpeg;base64," + base64.b64encode(path.read_bytes()).decode("ascii") if path.exists() else ""
+        )
+    return _portrait_cache[stem]
+
+
+# Return the asset file prefix for a world (handles the display-name casings).
+def world_prefix(world: str) -> str:
+    return _WORLD_PREFIX.get(world.strip().lower(), "darkFantasy")
+
+
+# Return the player's portrait for their world + school (tries casing variants).
+def player_portrait_uri(world: str, school: str) -> str:
+    prefix = world_prefix(world)
+    for variant in (school.title(), school.lower(), school.capitalize()):
+        uri = thumb_uri(f"{prefix}{variant}")
+        if uri:
+            return uri
+    return ""
+
+
+# Return the boss portrait (circle thumbnail) for a world.
+def boss_portrait_uri(world: str) -> str:
+    return thumb_uri(f"{world_prefix(world)}Boss")
+
+
+# Return the full boss splash image (medium JPEG) for the reveal screen.
+def boss_splash_uri(world: str) -> str:
+    return thumb_uri(f"{world_prefix(world)}Boss_splash")
+
+
 # Return a hero portrait with HP gem, defenses, status chips, and damage pop.
-def hero_html(player: PlayerState, school: School, title: str, enemy: bool, damage: int = 0) -> str:
+def hero_html(player: PlayerState, school: School, title: str, enemy: bool, damage: int = 0, portrait: str = "") -> str:
     block = f"<div class='block-gem'>{player.block}</div>" if player.block else ""
     ward = f"<div class='ward-gem'>{player.ward}</div>" if player.ward else ""
     pop = f"<div class='dmg-pop'>-{damage}</div>" if damage else ""
     hit = " hit" if damage else ""
+    face = (
+        f"<div class='hero-face portrait' style=\"background-image:url('{portrait}')\"></div>"
+        if portrait
+        else f"<div class='hero-face'>{school_mark(school)}</div>"
+    )
     return (
         f"<div class='hero {'enemy' if enemy else 'you'}'>"
-        f"<div class='hero-frame{hit}'><div class='hero-face'>{school_mark(school)}</div>"
+        f"<div class='hero-frame{hit}'>{face}"
         f"<div class='hp-gem'>{player.hp}</div>{block}{ward}{pop}</div>"
         f"<div class='hero-name'>{escape_html(title)}</div>"
         f"{status_chips_html(player)}"