finished base

ai_runtime.py

@@ -7,6 +7,7 @@ DEFAULT_MINICPM_MODEL_PATH = Path("models/minicpm-v-4.6-gguf/MiniCPM-V-4.6-Q4_K_
 DEFAULT_CARD_PORT = 8090
 DEFAULT_APP_PORT = 7860
 DEFAULT_BOSS_MODEL = "mlx-community/Nemotron-Mini-4B-Instruct-4bit-mlx"
+DEFAULT_ART_MODEL = "stabilityai/sdxl-turbo"
 
 
 # Return the OpenAI-compatible chat endpoint for a local port.
@@ -25,7 +26,9 @@ def minicpm_server_command(model_path: Path = DEFAULT_MINICPM_MODEL_PATH, port:
         "--port",
         str(port),
         "--ctx-size",
-        "4096",
+        "16384",
+        "--parallel",
+        "4",
         "--n-gpu-layers",
         "99",
     )
@@ -39,13 +42,19 @@ def local_ai_env(card_port: int = DEFAULT_CARD_PORT) -> dict[str, str]:
             "TABRAS_CARD_BACKEND": "llamacpp",
             "TABRAS_CARD_ENDPOINT": chat_endpoint(card_port),
             "TABRAS_CARD_MODEL": "minicpm-v-4.6-q4",
-            "TABRAS_CARD_TEMPERATURE": "0.0",
-            "TABRAS_CARD_MAX_TOKENS": "220",
+            "TABRAS_CARD_TEMPERATURE": "0.7",
+            "TABRAS_CARD_MAX_TOKENS": "192",
             "TABRAS_AI_BOSS": "1",
             "TABRAS_BOSS_BACKEND": "mlx",
             "TABRAS_BOSS_MODEL": DEFAULT_BOSS_MODEL,
             "TABRAS_BOSS_TEMPERATURE": "0.2",
             "TABRAS_BOSS_MAX_TOKENS": "96",
+            "TABRAS_ART_BACKEND": "diffusers",
+            "TABRAS_ART_MODEL": DEFAULT_ART_MODEL,
+            "TABRAS_ART_STEPS": "4",
+            "TABRAS_ART_GUIDANCE": "0.0",
+            "TABRAS_ART_WIDTH": "512",
+            "TABRAS_ART_HEIGHT": "320",
         }
     )
     return env

app.py

@@ -1,22 +1,66 @@
+import base64
+import mimetypes
 import time
+from dataclasses import replace
+from pathlib import Path
+from random import Random
 
 import gradio as gr
 
-from clients import card_client_from_env
+from clients import art_client_from_env, card_client_from_env
 from primitives import School
 from ui import (
     CARD_PANEL_COUNT,
     HAND_PANEL_COUNT,
     RunState,
     board_html,
-    choose_draft_card_steps,
+    choose_draft_card_loading_steps,
+    collect_ready_pack,
     draft_screen_html,
     log_html,
-    new_run,
+    new_run_shell,
     pass_turn_steps,
     play_hand_card_steps,
+    queue_next_pack,
+    refresh_art,
 )
 
+ASSETS = Path(__file__).parent / "assets"
+
+
+# Encode a bundled image asset as a CSS-ready data URI (HF-Spaces safe, no static paths).
+def asset_data_uri(name: str, mime: str = "image/jpeg") -> str:
+    encoded = base64.b64encode((ASSETS / name).read_bytes()).decode("ascii")
+    return f"data:{mime};base64,{encoded}"
+
+
+# Encode an optional bundled image asset as a CSS-ready data URI.
+def optional_asset_data_uri(name: str) -> str:
+    path = optional_asset_path(name)
+    if path is None:
+        return ""
+    mime = mimetypes.guess_type(path.name)[0] or "image/jpeg"
+    encoded = base64.b64encode(path.read_bytes()).decode("ascii")
+    return f"data:{mime};base64,{encoded}"
+
+
+# Return the first matching asset path, accepting common image extensions.
+def optional_asset_path(name: str) -> Path | None:
+    path = ASSETS / name
+    if path.exists():
+        return path
+    if path.suffix:
+        for suffix in (".jpg", ".jpeg", ".png", ".webp"):
+            candidate = path.with_suffix(suffix)
+            if candidate.exists():
+                return candidate
+    return None
+
+
+INN_BG = asset_data_uri("inn_bg.jpg")
+WOOD_BG = asset_data_uri("wood_board.jpg")
+
+
 HEAD = """
 <script>
 function tabrasClick(id) {
@@ -34,14 +78,16 @@ function tabrasPlay(id, card) {
 
 CSS = """
 .gradio-container {
-  background: radial-gradient(ellipse at 50% 20%, #3a2615 0%, #241608 55%, #140b04 100%) fixed;
+  background: linear-gradient(rgba(10, 6, 14, 0.82), rgba(6, 4, 9, 0.9)), url("__INN_BG__") center / cover fixed;
   color: #f4ead9;
   max-width: 100% !important;
 }
 footer { display: none !important; }
 .hidden-controls { display: none !important; }
+*, *::before, *::after { box-sizing: border-box; }
 gradio-app, body {
-  background: radial-gradient(ellipse at 50% 20%, #3a2615 0%, #241608 55%, #140b04 100%) fixed !important;
+  background: linear-gradient(rgba(10, 6, 14, 0.82), rgba(6, 4, 9, 0.9)), url("__INN_BG__") center / cover fixed !important;
+  overflow-x: hidden;
 }
 .gradio-container .block, .gradio-container .form, .gradio-container .gr-group, .gradio-container .styler {
   background: transparent !important;
@@ -54,6 +100,29 @@ button.primary {
   border: 2px solid #f6dd9a !important;
   font-weight: 800 !important;
 }
+#play-now-btn {
+  width: auto !important;
+  min-width: 170px !important;
+  max-width: 220px !important;
+  align-self: center !important;
+}
+#play-now-btn button {
+  width: auto !important;
+  min-width: 170px !important;
+  padding: 10px 28px !important;
+}
+#start-draft-btn {
+  width: auto !important;
+  min-width: 150px !important;
+  max-width: 200px !important;
+  align-self: center !important;
+  margin: 0 auto !important;
+}
+#start-draft-btn button {
+  width: auto !important;
+  min-width: 150px !important;
+  padding: 10px 24px !important;
+}
 
 .tabras-title {
   min-height: 70vh;
@@ -66,27 +135,117 @@ button.primary {
 .tabras-title h1 {
   font-size: 76px;
   margin: 0 0 12px;
-  color: #f8e7c4;
-  text-shadow: 0 3px 18px rgba(0, 0, 0, 0.65);
+  color: #f6f0ff;
+  text-shadow: 0 0 30px rgba(160, 90, 255, 0.6), 0 3px 18px rgba(0, 0, 0, 0.65);
 }
 .gradio-container .setup-panel {
-  background: rgba(36, 22, 13, 0.78) !important;
-  border: 2px solid rgba(255, 225, 172, 0.25) !important;
+  background: rgba(26, 20, 46, 0.82) !important;
+  border: 2px solid rgba(190, 160, 255, 0.3) !important;
   box-shadow: 0 18px 48px rgba(0, 0, 0, 0.35) !important;
   padding: 18px !important;
   border-radius: 14px !important;
   max-width: 560px;
   margin: 8vh auto 0 !important;
 }
+.step-kicker {
+  color: #ffd35c;
+  font-size: 13px;
+  font-weight: 900;
+  letter-spacing: 0.12em;
+  text-transform: uppercase;
+  margin-bottom: 8px;
+}
+.setup-panel h2 {
+  margin: 0 0 12px;
+  color: #f6f0ff;
+  font-size: 28px;
+}
+.choice-row button {
+  min-height: 46px;
+}
+.selector-grid {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 14px;
+  width: min(980px, 92vw);
+  margin: 0 auto;
+}
+.selector-panel {
+  position: relative;
+  min-height: 360px;
+  border: 2px solid rgba(190, 160, 255, 0.34);
+  border-radius: 14px;
+  overflow: hidden;
+  cursor: pointer;
+  background: var(--selector-fallback);
+  background-size: cover;
+  background-position: center;
+  box-shadow: 0 18px 42px rgba(0, 0, 0, 0.42);
+  transition: transform 0.16s ease, border-color 0.16s ease, box-shadow 0.16s ease, filter 0.16s ease;
+}
+.selector-image {
+  position: absolute;
+  inset: 0;
+  width: 100%;
+  height: 100%;
+  object-fit: cover;
+}
+.selector-panel::after {
+  content: "";
+  position: absolute;
+  inset: 0;
+  background: linear-gradient(180deg, rgba(12, 8, 30, 0.06), rgba(12, 8, 30, 0.88));
+  pointer-events: none;
+}
+.selector-panel:hover {
+  transform: translateY(-8px);
+  border-color: #ffd35c;
+  box-shadow: 0 0 28px rgba(255, 211, 92, 0.22), 0 24px 58px rgba(0, 0, 0, 0.52);
+  filter: saturate(1.1);
+}
+.selector-label {
+  position: absolute;
+  left: 18px;
+  right: 18px;
+  bottom: 18px;
+  color: #f6f0ff;
+  font-size: 26px;
+  font-weight: 900;
+  text-shadow: 0 3px 14px rgba(0, 0, 0, 0.82);
+  z-index: 2;
+}
+.selector-copy {
+  position: absolute;
+  inset: 0;
+  display: flex;
+  align-items: flex-end;
+  padding: 18px;
+  color: #f6f0ff;
+  font-size: 17px;
+  font-weight: 700;
+  line-height: 1.35;
+  opacity: 0;
+  background: linear-gradient(180deg, rgba(8, 4, 20, 0.24), rgba(8, 4, 20, 0.88));
+  text-shadow: 0 2px 10px rgba(0, 0, 0, 0.9);
+  transition: opacity 0.16s ease;
+  z-index: 3;
+}
+.selector-panel:hover .selector-copy {
+  opacity: 1;
+}
+@media (max-width: 900px) {
+  .selector-grid { grid-template-columns: 1fr; }
+  .selector-panel { min-height: 240px; }
+}
 
 /* ---- card faces ---- */
 .tabras-card {
   position: relative;
   border-radius: 10px;
   padding: 26px 10px 8px;
-  background: linear-gradient(180deg, #2b2119, #17100b);
-  border: 2px solid #bb8c4d;
-  color: #f8ead2;
+  background: linear-gradient(180deg, #2a2347, #151028);
+  border: 2px solid #8d7bd6;
+  color: #f0eaff;
   box-shadow: 0 10px 28px rgba(0, 0, 0, 0.35);
   display: flex;
   flex-direction: column;
@@ -112,34 +271,88 @@ button.primary {
   z-index: 2;
 }
 .card-name { font-size: 13px; font-weight: 800; line-height: 1.15; min-height: 30px; }
-.school-fire .card-name { color: #ffb199; }
-.school-ice .card-name { color: #aadcff; }
-.school-earth .card-name { color: #c9e29a; }
+.school-fire .card-name { color: #ff9d80; }
+.school-ice .card-name { color: #8fdfff; }
+.school-earth .card-name { color: #aaf08a; }
+.tabras-card.school-fire { border-color: #e06a48; box-shadow: 0 10px 28px rgba(0, 0, 0, 0.35), 0 0 14px rgba(255, 110, 70, 0.22); }
+.tabras-card.school-ice { border-color: #4fb6e8; box-shadow: 0 10px 28px rgba(0, 0, 0, 0.35), 0 0 14px rgba(90, 200, 255, 0.22); }
+.tabras-card.school-earth { border-color: #6fc454; box-shadow: 0 10px 28px rgba(0, 0, 0, 0.35), 0 0 14px rgba(130, 230, 110, 0.22); }
 .card-art {
   height: 64px;
   border-radius: 6px;
-  border: 1px dashed rgba(255, 232, 188, 0.25);
-  background: linear-gradient(135deg, rgba(77, 52, 35, 0.55), rgba(23, 32, 42, 0.55));
+  border: 1px solid rgba(200, 170, 255, 0.3);
+  background: linear-gradient(135deg, rgba(80, 60, 140, 0.5), rgba(20, 40, 70, 0.55));
+  overflow: hidden;
 }
-.card-rules { font-size: 11.5px; line-height: 1.3; min-height: 44px; color: #f3e6cb; }
+.card-art.generated {
+  border-style: solid;
+  background-color: #0d0a16;
+  background-repeat: no-repeat;
+  background-size: cover;
+  background-position: center;
+}
+.pending-art {
+  position: relative;
+  border-color: rgba(190, 160, 255, 0.28);
+}
+.pending-art::after {
+  content: "";
+  position: absolute;
+  inset: 0;
+  background: linear-gradient(100deg, transparent 0%, rgba(255, 255, 255, 0.12) 42%, transparent 70%);
+  transform: translateX(-120%);
+  animation: art-sheen 1.8s ease-in-out infinite;
+}
+.school-art-fire { background: radial-gradient(circle at 40% 35%, rgba(255, 155, 80, 0.34), transparent 32%), linear-gradient(135deg, #3a1724, #180d1f 72%); }
+.school-art-ice { background: radial-gradient(circle at 45% 35%, rgba(125, 220, 255, 0.32), transparent 34%), linear-gradient(135deg, #172c4a, #111328 72%); }
+.school-art-earth { background: radial-gradient(circle at 45% 38%, rgba(170, 240, 138, 0.28), transparent 34%), linear-gradient(135deg, #20331f, #111328 72%); }
+@keyframes art-sheen {
+  from { transform: translateX(-120%); }
+  to { transform: translateX(120%); }
+}
+.card-rules { font-size: 11.5px; line-height: 1.3; min-height: 44px; color: #ece4ff; }
 .card-flavor {
-  color: #cdb997;
+  color: #b9a8e0;
   font-size: 10px;
   font-style: italic;
-  border-top: 1px solid rgba(255, 232, 188, 0.18);
+  border-top: 1px solid rgba(200, 170, 255, 0.2);
   padding-top: 4px;
 }
 
 /* ---- draft screen ---- */
-.draft-board { display: flex; flex-direction: column; align-items: center; gap: 20px; padding: 18px; }
+.draft-board {
+  width: min(1220px, calc(100vw - 56px));
+  min-height: 82vh;
+  margin: 0 auto;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  gap: 24px;
+  padding: 20px 18px;
+}
 .draft-banner { text-align: center; }
-.draft-banner h2 { margin: 0; color: #f2c24d; letter-spacing: 0.08em; text-transform: uppercase; }
-.draft-banner p { margin: 4px 0 0; color: #cdb997; }
-.draft-pack { display: flex; gap: 28px; }
-.draft-card { width: 215px; cursor: pointer; transition: transform 0.15s ease, box-shadow 0.15s ease; animation: pack-in 0.5s ease backwards; }
+.draft-banner h2 { margin: 0; color: #ffd35c; letter-spacing: 0.08em; text-transform: uppercase; text-shadow: 0 0 18px rgba(255, 211, 92, 0.45); font-size: 30px; }
+.draft-banner p { margin: 6px 0 0; color: #b9a8e0; font-size: 17px; }
+.draft-pack {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 300px));
+  gap: clamp(16px, 2vw, 30px);
+  justify-content: center;
+  align-items: stretch;
+  width: 100%;
+}
+.draft-card {
+  width: 100%;
+  min-width: 0;
+  min-height: 405px;
+  cursor: pointer;
+  transition: transform 0.15s ease, box-shadow 0.15s ease;
+  animation: pack-in 0.5s ease backwards;
+}
 .draft-pack .draft-card:nth-child(2) { animation-delay: 0.1s; }
 .draft-pack .draft-card:nth-child(3) { animation-delay: 0.2s; }
-.draft-card:hover { transform: translateY(-14px) scale(1.06); box-shadow: 0 0 26px rgba(240, 200, 110, 0.5); }
+.draft-card:hover { transform: translateY(-10px) scale(1.045); box-shadow: 0 0 22px rgba(56, 232, 210, 0.5); }
 @keyframes pack-in {
   from { opacity: 0; transform: translateY(28px) scale(0.92); }
   to { opacity: 1; transform: none; }
@@ -154,24 +367,135 @@ button.primary {
   30% { opacity: 1; transform: scale(1.08); box-shadow: 0 0 44px rgba(242, 194, 77, 0.95); }
   to { opacity: 0; transform: translateY(-34px) scale(1.02); box-shadow: 0 0 30px rgba(242, 194, 77, 0.6); }
 }
-.draft-card .card-name { font-size: 17px; min-height: 42px; }
+.draft-card .card-name { font-size: 17px; min-height: 44px; }
 .draft-card .card-art { height: 112px; }
-.draft-card .card-rules { font-size: 13.5px; min-height: 62px; }
+.draft-card .card-rules { font-size: 13px; min-height: 64px; }
 .draft-card .card-flavor { font-size: 12px; }
-.deck-strip { display: flex; flex-wrap: wrap; gap: 6px; justify-content: center; max-width: 920px; align-items: center; }
-.deck-strip-label { font-weight: 800; color: #f2c24d; margin-right: 6px; }
-.deck-chip { background: rgba(0, 0, 0, 0.35); border: 1px solid #7c5a33; border-radius: 12px; padding: 2px 10px; font-size: 11px; }
-.deck-chip b { color: #7fd4ff; }
-.deck-chip.anchor { border-color: #f2c24d; box-shadow: 0 0 8px rgba(242, 194, 77, 0.35); }
+.starter-board { min-height: 82vh; gap: 22px; }
+.starter-grid {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(190px, 1fr));
+  gap: 18px;
+  width: min(920px, 92vw);
+}
+.starter-card { min-height: 260px; }
+.starter-card .card-name { font-size: 17px; min-height: 40px; }
+.starter-card .card-art { height: 70px; }
+.starter-card .card-rules { font-size: 13.5px; min-height: 46px; }
+.starter-card .card-flavor { font-size: 12px; }
+.loading-board { gap: 30px; }
+.draft-loading {
+  width: min(520px, 86vw);
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  gap: 12px;
+  padding: 20px 22px;
+  border: 1px solid rgba(255, 211, 92, 0.35);
+  border-radius: 12px;
+  background: rgba(12, 8, 30, 0.6);
+  box-shadow: 0 0 24px rgba(255, 211, 92, 0.12);
+}
+.loading-title {
+  color: #ffd35c;
+  font-size: 20px;
+  font-weight: 900;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+}
+.loading-subtitle {
+  color: #b9a8e0;
+  font-size: 13px;
+  text-align: center;
+}
+.rules-screen {
+  min-height: 74vh;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  padding: 24px;
+}
+.rules-card {
+  width: min(780px, 92vw);
+  border: 2px solid rgba(255, 211, 92, 0.32);
+  border-radius: 16px;
+  background: rgba(16, 10, 34, 0.82);
+  box-shadow: 0 24px 70px rgba(0, 0, 0, 0.45), 0 0 28px rgba(255, 211, 92, 0.12);
+  padding: 30px;
+}
+.rules-card h1 {
+  margin: 0 0 12px;
+  color: #ffd35c;
+  letter-spacing: 0.08em;
+  text-transform: uppercase;
+}
+.rules-card p {
+  color: #d9d0f0;
+  font-size: 16px;
+  line-height: 1.45;
+}
+.rules-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 12px;
+  margin-top: 18px;
+}
+.rule-tile {
+  border: 1px solid rgba(190, 160, 255, 0.28);
+  border-radius: 10px;
+  padding: 14px;
+  background: rgba(42, 35, 71, 0.62);
+}
+.rule-tile b {
+  display: block;
+  color: #f6f0ff;
+  margin-bottom: 6px;
+}
+.rule-tile span {
+  color: #b9a8e0;
+  font-size: 14px;
+  line-height: 1.35;
+}
+.loading-bar {
+  width: 100%;
+  height: 12px;
+  overflow: hidden;
+  border-radius: 999px;
+  background: rgba(20, 14, 50, 0.95);
+  border: 1px solid rgba(95, 220, 255, 0.35);
+}
+.loading-bar span {
+  display: block;
+  width: 40%;
+  height: 100%;
+  border-radius: inherit;
+  background: linear-gradient(90deg, #38e8d2, #ffd35c, #ff9d80);
+  animation: loading-sweep 1.15s ease-in-out infinite;
+}
+@keyframes loading-sweep {
+  0% { transform: translateX(-110%); }
+  100% { transform: translateX(260%); }
+}
+.deck-strip { display: flex; flex-wrap: wrap; gap: 7px; justify-content: center; max-width: 1100px; align-items: center; }
+.deck-strip-label { font-weight: 800; color: #f2c24d; margin-right: 6px; font-size: 18px; }
+.deck-chip { background: rgba(10, 6, 30, 0.5); border: 1px solid #5b4a8f; border-radius: 12px; padding: 3px 12px; font-size: 13px; }
+.deck-chip b { color: #38e8d2; }
+.deck-chip.anchor { border-color: #ffd35c; box-shadow: 0 0 8px rgba(255, 211, 92, 0.4); }
+@media (max-width: 900px) {
+  .draft-board { min-height: auto; justify-content: flex-start; }
+  .draft-pack { grid-template-columns: 1fr; max-width: 320px; }
+  .draft-card { width: min(300px, 92vw); min-height: 405px; }
+  .starter-grid { grid-template-columns: repeat(2, minmax(150px, 1fr)); }
+}
 
 /* ---- battle board ---- */
 .board {
   position: relative;
-  border: 4px solid #6e4f2a;
+  border: 4px solid #7a5630;
   border-radius: 22px;
   padding: 8px 14px;
-  background: radial-gradient(ellipse at center, #5d3b1e 0%, #4a2e15 60%, #38220e 100%);
-  box-shadow: inset 0 0 60px rgba(0, 0, 0, 0.55), 0 24px 60px rgba(0, 0, 0, 0.5);
+  background: linear-gradient(rgba(24, 13, 5, 0.42), rgba(14, 7, 2, 0.6)), url("__WOOD_BG__") center / cover;
+  box-shadow: inset 0 0 70px rgba(0, 0, 0, 0.62), 0 0 30px rgba(150, 95, 40, 0.25), 0 24px 60px rgba(0, 0, 0, 0.55);
   overflow: hidden;
 }
 .zone { position: relative; display: flex; align-items: center; justify-content: center; }
@@ -180,13 +504,13 @@ button.primary {
 .pile {
   width: 64px;
   text-align: center;
-  border: 2px solid #8a6536;
+  border: 2px solid #5b4a8f;
   border-radius: 8px;
   padding: 6px 0 3px;
-  background: repeating-linear-gradient(45deg, #241509 0, #241509 6px, #2f1c0d 6px, #2f1c0d 12px);
+  background: repeating-linear-gradient(45deg, #1c1535 0, #1c1535 6px, #251c45 6px, #251c45 12px);
 }
-.pile span { font-weight: 900; font-size: 18px; color: #f4d69b; }
-.pile label { display: block; font-size: 9px; letter-spacing: 0.12em; text-transform: uppercase; color: #b09a72; }
+.pile span { font-weight: 900; font-size: 18px; color: #ffd35c; }
+.pile label { display: block; font-size: 9px; letter-spacing: 0.12em; text-transform: uppercase; color: #9d8fc7; }
 .fatigue-warn { color: #ff8d7a; font-size: 10px; font-weight: 800; }
 
 .hero { display: flex; flex-direction: column; align-items: center; gap: 3px; }
@@ -196,7 +520,7 @@ button.primary {
   height: 100%;
   border-radius: 50% 50% 46% 46%;
   border: 4px solid #b08a4f;
-  background: radial-gradient(circle at 50% 30%, #7a5836, #2a1a0e 75%);
+  background: radial-gradient(circle at 50% 30%, #4a3e72, #1b1430 75%);
   display: flex;
   align-items: center;
   justify-content: center;
@@ -265,9 +589,9 @@ button.primary {
   width: 52px;
   height: 72px;
   border-radius: 6px;
-  border: 2px solid #a77c43;
+  border: 2px solid #7a5fc0;
   margin: 0 -10px;
-  background: repeating-linear-gradient(45deg, #2c1b12 0, #2c1b12 7px, #3a2417 7px, #3a2417 14px);
+  background: repeating-linear-gradient(45deg, #2a1745 0, #2a1745 7px, #371d5c 7px, #371d5c 14px);
   box-shadow: 0 6px 14px rgba(0, 0, 0, 0.4);
   transform: rotate(3deg);
 }
@@ -278,7 +602,7 @@ button.primary {
   min-height: 118px;
   margin: 8px 36px;
   border-radius: 14px;
-  background: rgba(0, 0, 0, 0.18);
+  background: rgba(10, 6, 30, 0.35);
   box-shadow: inset 0 0 30px rgba(0, 0, 0, 0.35);
   display: flex;
   flex-direction: column;
@@ -293,7 +617,7 @@ button.primary {
   font-weight: 800;
   letter-spacing: 0.12em;
   text-transform: uppercase;
-  color: #e9cf9b;
+  color: #cfc3f2;
   font-size: 13px;
 }
 .end-turn {
@@ -342,11 +666,11 @@ button.primary {
   padding: 1px 10px;
   border-radius: 10px;
 }
-.play-label.you { color: #9fe7ff; background: rgba(30, 90, 140, 0.45); border: 1px solid #4fa3d4; }
-.play-label.boss { color: #ffb9a8; background: rgba(140, 40, 20, 0.45); border: 1px solid #c95a3a; }
+.play-label.you { color: #7df5e2; background: rgba(20, 90, 80, 0.45); border: 1px solid #2aa896; }
+.play-label.boss { color: #f0b8ff; background: rgba(110, 30, 130, 0.45); border: 1px solid #b14ad0; }
 .played-card { width: 132px; }
-.played-card.player-play { box-shadow: 0 0 22px rgba(120, 220, 255, 0.55); }
-.played-card.enemy-play { box-shadow: 0 0 22px rgba(255, 90, 60, 0.6); border-color: #c95a3a; }
+.played-card.player-play { box-shadow: 0 0 22px rgba(56, 232, 210, 0.6); }
+.played-card.enemy-play { box-shadow: 0 0 22px rgba(232, 91, 255, 0.6); border-color: #b14ad0; }
 @keyframes play-in {
   from { transform: translateY(120px) rotateY(90deg) scale(0.4); opacity: 0; }
   60% { transform: translateY(-6px) rotateY(0deg) scale(1.12); opacity: 1; }
@@ -374,15 +698,15 @@ button.primary {
   transform-origin: 50% 130%;
   transition: transform 0.15s ease, box-shadow 0.15s ease;
   cursor: pointer;
-  box-shadow: 0 0 14px rgba(110, 230, 120, 0.5);
-  border-color: #7fdf8a;
+  box-shadow: 0 0 14px rgba(56, 232, 210, 0.55);
+  border-color: #45e8c8;
 }
 .hand-card:hover {
   transform: rotate(0deg) translateY(-48px) scale(1.45);
   z-index: 99 !important;
-  box-shadow: 0 0 24px rgba(120, 255, 140, 0.45), 0 24px 50px rgba(0, 0, 0, 0.6);
+  box-shadow: 0 0 24px rgba(56, 232, 210, 0.5), 0 24px 50px rgba(0, 0, 0, 0.6);
 }
-.hand-card.unplayable { filter: grayscale(0.8) brightness(0.7); cursor: default; box-shadow: 0 10px 28px rgba(0, 0, 0, 0.35); border-color: #6b5634; }
+.hand-card.unplayable { filter: grayscale(0.8) brightness(0.7); cursor: default; box-shadow: 0 10px 28px rgba(0, 0, 0, 0.35); border-color: #4a3f6e; }
 .hand-card.unplayable:hover { box-shadow: 0 24px 50px rgba(0, 0, 0, 0.6); }
 .hand-card.launching {
   transform: translateY(-170px) scale(1.08) rotate(0deg) !important;
@@ -404,17 +728,17 @@ button.primary {
   animation: splash-bg 1.9s ease forwards;
 }
 @keyframes splash-bg {
-  0% { background: rgba(8, 4, 2, 0); }
-  18% { background: rgba(8, 4, 2, 0.74); }
-  72% { background: rgba(8, 4, 2, 0.74); }
-  100% { background: rgba(8, 4, 2, 0); }
+  0% { background: rgba(6, 3, 18, 0); }
+  18% { background: rgba(6, 3, 18, 0.78); }
+  72% { background: rgba(6, 3, 18, 0.78); }
+  100% { background: rgba(6, 3, 18, 0); }
 }
 .splash-round {
   font-size: 50px;
   font-weight: 900;
   letter-spacing: 0.3em;
-  color: #f6dd9a;
-  text-shadow: 0 0 34px rgba(246, 221, 154, 0.85), 0 4px 8px #000;
+  color: #ffd35c;
+  text-shadow: 0 0 34px rgba(255, 211, 92, 0.9), 0 4px 8px #000;
   animation: splash 1.9s ease forwards;
 }
 .splash-initiative {
@@ -423,8 +747,8 @@ button.primary {
   letter-spacing: 0.26em;
   animation: splash 1.65s ease 0.25s both;
 }
-.splash-initiative.you { color: #9fe7ff; text-shadow: 0 0 24px rgba(110, 200, 255, 0.8); }
-.splash-initiative.boss { color: #ff8d7a; text-shadow: 0 0 24px rgba(255, 80, 50, 0.8); }
+.splash-initiative.you { color: #38e8d2; text-shadow: 0 0 24px rgba(56, 232, 210, 0.85); }
+.splash-initiative.boss { color: #f06bff; text-shadow: 0 0 24px rgba(232, 91, 255, 0.85); }
 @keyframes splash {
   0% { opacity: 0; transform: scale(2.2); }
   25% { opacity: 1; transform: scale(1); }
@@ -439,9 +763,9 @@ button.primary {
   z-index: 60;
   padding: 5px 16px;
   border-radius: 14px;
-  background: rgba(20, 10, 6, 0.92);
-  border: 1px solid #c95a3a;
-  color: #ffb9a8;
+  background: rgba(20, 10, 36, 0.94);
+  border: 1px solid #b14ad0;
+  color: #f0c4ff;
   font-weight: 700;
   font-size: 12px;
   letter-spacing: 0.08em;
@@ -452,7 +776,7 @@ button.primary {
   0%, 100% { opacity: 0.55; transform: translateX(-50%) scale(1); }
   50% { opacity: 1; transform: translateX(-50%) scale(1.06); }
 }
-.board.thinking .hero.enemy .hero-face { box-shadow: 0 0 28px rgba(255, 90, 50, 0.6); }
+.board.thinking .hero.enemy .hero-face { box-shadow: 0 0 28px rgba(232, 91, 255, 0.6); }
 
 .winner-banner {
   position: absolute;
@@ -462,7 +786,7 @@ button.primary {
   gap: 16px;
   align-items: center;
   justify-content: center;
-  background: rgba(10, 5, 2, 0.74);
+  background: rgba(8, 5, 22, 0.78);
   z-index: 200;
   border-radius: 18px;
 }
@@ -473,7 +797,7 @@ button.primary {
 }
 .winner-banner.victory h1 { color: #ffd98c; text-shadow: 0 0 30px rgba(255, 200, 90, 0.7); }
 .winner-banner.defeat h1 { color: #ff7a6a; text-shadow: 0 0 30px rgba(255, 70, 40, 0.6); }
-.winner-banner.draw h1 { color: #cdb997; }
+.winner-banner.draw h1 { color: #b9a8e0; }
 .new-run {
   padding: 12px 30px;
   border-radius: 24px;
@@ -485,7 +809,7 @@ button.primary {
 }
 .game-over .hand-fan, .game-over .end-turn { pointer-events: none; }
 
-.log-panel { background: rgba(20, 12, 7, 0.8) !important; border: 2px solid #6e4f2a; border-radius: 14px; padding: 8px; }
+.log-panel { background: rgba(18, 14, 38, 0.85) !important; border: 2px solid #5b4a8f; border-radius: 14px; padding: 8px; }
 .log-scroll {
   display: flex;
   flex-direction: column-reverse;
@@ -493,46 +817,61 @@ button.primary {
   max-height: 600px;
   overflow-y: auto;
   font-size: 11.5px;
-  color: #e7d5af;
+  color: #d9d0f0;
 }
 .log-line { padding: 4px 8px; border-left: 3px solid transparent; border-radius: 4px; line-height: 1.35; }
-.log-line b { color: #ffd98c; font-size: 12.5px; }
+.log-line b { color: #ffd35c; font-size: 12.5px; }
 .log-owner { display: block; font-size: 9px; letter-spacing: 0.12em; text-transform: uppercase; opacity: 0.7; }
 .log-rules { display: block; font-size: 10.5px; opacity: 0.85; }
-.log-play.log-you { border-left-color: #4fa3d4; background: rgba(40, 90, 130, 0.2); }
-.log-play.log-boss { border-left-color: #c95a3a; background: rgba(140, 50, 25, 0.2); }
+.log-play.log-you { border-left-color: #38e8d2; background: rgba(30, 120, 110, 0.22); }
+.log-play.log-boss { border-left-color: #e85bff; background: rgba(120, 40, 140, 0.22); }
 .log-round {
   text-align: center;
-  color: #f2c24d;
+  color: #ffd35c;
   font-weight: 800;
   letter-spacing: 0.06em;
   margin-top: 8px;
-  border-top: 1px solid rgba(242, 194, 77, 0.3);
+  border-top: 1px solid rgba(255, 211, 92, 0.35);
   padding-top: 6px;
 }
-.log-winner { text-align: center; color: #ffd98c; font-weight: 900; font-size: 13px; border: 1px solid #f2c24d; background: rgba(120, 85, 10, 0.3); }
+.log-winner { text-align: center; color: #ffd35c; font-weight: 900; font-size: 13px; border: 1px solid #ffd35c; background: rgba(255, 211, 92, 0.14); }
 .log-muted { opacity: 0.55; font-style: italic; }
-.log-draft { color: #c9e29a; }
-.log-scroll > .log-line:first-child { box-shadow: inset 0 0 0 1px rgba(255, 217, 140, 0.3); }
+.log-draft { color: #aaf08a; }
+.log-scroll > .log-line:first-child { box-shadow: inset 0 0 0 1px rgba(255, 211, 92, 0.35); }
 """
 
+CSS = CSS.replace("__INN_BG__", INN_BG).replace("__WOOD_BG__", WOOD_BG)
+
 
 # Build all Gradio components for the Tabras app.
 def build_app() -> gr.Blocks:
     with gr.Blocks(title="Tabras") as app:
         state = gr.State(None)
+        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>")
-            play_now = gr.Button("Play Now", variant="primary")
+            play_now = gr.Button("Play Now", variant="primary", elem_id="play-now-btn")
 
-        with gr.Group(visible=False, elem_id="setup-screen") as setup_group:
+        with gr.Group(visible=False, elem_id="name-screen") as name_group:
             with gr.Column(elem_classes=["setup-panel"]):
-                gr.Markdown("## Set the table")
+                gr.HTML("<div class='step-kicker'>Step 1 of 3</div><h2>Name your challenger</h2>")
                 name = gr.Textbox(label="Name", value="Vishnu")
-                world = gr.Textbox(label="What's your world?", value="dark fantasy")
-                school = gr.Radio(["fire", "ice", "earth"], label="What's your favorite school of magic?", value="fire")
-                begin = gr.Button("Begin Draft", variant="primary")
+                name_next = gr.Button("Continue", variant="primary")
+
+        with gr.Group(visible=False, elem_id="school-screen") as school_group:
+            with gr.Column(elem_classes=["setup-panel"]):
+                gr.HTML("<div class='step-kicker'>Step 3 of 3</div><h2>Choose your spell school</h2>")
+            school_view = gr.HTML(school_selector_html("Dark Fantasy"))
+
+        with gr.Group(visible=False, elem_id="background-screen") as background_group:
+            with gr.Column(elem_classes=["setup-panel"]):
+                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="rules-screen") as rules_group:
+            rules_view = gr.HTML()
+            continue_rules = gr.Button("Start Draft", variant="primary", elem_id="start-draft-btn")
 
         with gr.Group(visible=False, elem_id="draft-screen") as draft_group:
             draft_view = gr.HTML()
@@ -548,19 +887,44 @@ def build_app() -> gr.Blocks:
         with gr.Row(elem_classes=["hidden-controls"]):
             hand_buttons = [gr.Button("", elem_id=f"hand-btn-{index}") for index in range(HAND_PANEL_COUNT)]
             draft_buttons = [gr.Button("", elem_id=f"draft-btn-{index}") for index in range(CARD_PANEL_COUNT)]
+            background_buttons = [gr.Button("", elem_id=f"background-btn-{slug}") for slug in ("dark-fantasy", "cyberpunk", "anime")]
+            school_buttons = [gr.Button("", elem_id=f"school-btn-{slug}") for slug in ("fire", "ice", "earth")]
             end_turn = gr.Button("", elem_id="end-turn-btn")
             restart = gr.Button("", elem_id="restart-btn")
+            world_state = gr.State("Dark Fantasy")
 
-        outputs = [state, title_group, setup_group, draft_group, battle_group, draft_view, board_view, log_view]
+        outputs = [
+            state,
+            screen_state,
+            title_group,
+            name_group,
+            school_group,
+            background_group,
+            rules_group,
+            draft_group,
+            battle_group,
+            rules_view,
+            draft_view,
+            board_view,
+            log_view,
+            school_view,
+            world_state,
+        ]
 
-        play_now.click(show_setup, outputs=outputs)
-        begin.click(begin_run, inputs=[name, world, school], outputs=outputs)
+        play_now.click(show_name, outputs=outputs)
+        name_next.click(show_background, outputs=outputs)
+        for value, button in zip(("Dark Fantasy", "Cyberpunk", "Anime"), background_buttons):
+            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)
+        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)
         for index, button in enumerate(hand_buttons):
             button.click(indexed_handler(play_card, index), inputs=[state], outputs=outputs)
         end_turn.click(end_player_turn, inputs=[state], outputs=outputs)
-        restart.click(show_setup, outputs=outputs)
+        restart.click(show_name, outputs=outputs)
+        gr.Timer(0.8).tick(refresh_screen, inputs=[state, screen_state, world_state], outputs=outputs)
 
     return app
 
@@ -573,31 +937,72 @@ def indexed_handler(handler, index: int):
     return stream
 
 
-# Show the setup screen.
-def show_setup() -> list[object]:
-    return render(None, "setup")
+# Bind one string value into a handler.
+def value_handler(handler, value: str):
+    def call(*args):
+        return handler(value, *args)
+
+    return call
+
+
+# Show the name prompt.
+def show_name() -> list[object]:
+    return render(None, "name")
+
+
+# Show the school prompt.
+def show_school() -> list[object]:
+    return render(None, "school")
+
+
+# Show the background prompt.
+def show_background() -> list[object]:
+    return render(None, "background")
+
 
+# Store one background choice and advance to school selection.
+def choose_background(world: str) -> list[object]:
+    return render(None, "school", world)
 
-# Start a run from setup inputs.
-def begin_run(name: str, world: str, school: str) -> list[object]:
+
+# Start rules after one school selector is clicked.
+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.
+def start_rules(name: str, school: str, world: str) -> list[object]:
     client = card_client_from_env()
-    run_state = new_run(name, world, school_as_literal(school), client)
+    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")
+
+
+# Move from rules to draft, showing deck loading if the first pack is not ready.
+def show_draft_from_rules(run_state: RunState | None) -> list[object]:
+    if run_state is None:
+        return render(None, "name")
+    run_state = collect_ready_pack(refresh_art(run_state), card_client_from_env(), art_client_from_env())
+    if run_state is not None and not run_state.current_pack and run_state.duel is None:
+        run_state = replace(run_state, loading="Loading your deck")
     return render(run_state, "draft")
 
 
 # Choose one draft card, streaming the paced battle opening on the final pick.
 def draft_pick(run_state: RunState | None, index: int):
     if run_state is None:
-        yield render(None, "setup")
+        yield render(None, "name")
         return
     client = card_client_from_env()
-    yield from paced_frames(choose_draft_card_steps(run_state, index, client))
+    art_client = art_client_from_env()
+    yield from paced_frames(choose_draft_card_loading_steps(run_state, index, client, art_client))
 
 
 # Play one hand card by index, streaming the paced boss response.
 def play_card(run_state: RunState | None, index: int):
     if run_state is None:
-        yield render(None, "setup")
+        yield render(None, "name")
         return
     yield from paced_frames(play_hand_card_steps(run_state, index))
 
@@ -605,11 +1010,20 @@ def play_card(run_state: RunState | None, index: int):
 # End the player turn, streaming the paced boss response.
 def end_player_turn(run_state: RunState | None):
     if run_state is None:
-        yield render(None, "setup")
+        yield render(None, "name")
         return
     yield from paced_frames(pass_turn_steps(run_state))
 
 
+# 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"}:
+        screen = "title"
+    if screen in {"rules", "draft"}:
+        run_state = collect_ready_pack(refresh_art(run_state), card_client_from_env(), art_client_from_env())
+    return render(refresh_art(run_state), screen, world)
+
+
 # Yield rendered frames, letting each dramatic beat linger on screen.
 def paced_frames(steps):
     previous = None
@@ -623,28 +1037,132 @@ def paced_frames(steps):
 # Return how long one frame should stay on screen before the next.
 def frame_delay(state: RunState) -> float:
     if state.round_flash:
-        return 2.2
-    if state.boss_thinking:
         return 1.4
+    if state.boss_thinking:
+        return 0.35
     if state.pack_fading >= 0:
-        return 0.75
-    return 0.9
+        return 0.45
+    return 0.45
 
 
 # Render all app outputs.
-def render(run_state: RunState | None, screen: str) -> list[object]:
+def render(run_state: RunState | None, screen: str, world: str = "Dark Fantasy") -> list[object]:
+    run_state = refresh_art(run_state)
+    world = run_state.world if run_state is not None else world
     return [
         run_state,
+        screen,
         gr.update(visible=screen == "title"),
-        gr.update(visible=screen == "setup"),
+        gr.update(visible=screen == "name"),
+        gr.update(visible=screen == "school"),
+        gr.update(visible=screen == "background"),
+        gr.update(visible=screen == "rules"),
         gr.update(visible=screen == "draft"),
         gr.update(visible=screen == "battle"),
+        rules_html(run_state),
         draft_screen_html(run_state),
         board_html(run_state),
         log_html(run_state),
+        school_selector_html(world),
+        world,
     ]
 
 
+# Return HTML for image-backed background choices.
+def background_selector_html() -> str:
+    cards = (
+        selector_card("background-btn-dark-fantasy", "Dark Fantasy", "You are a mage in a forlorn, lost, and dark world.", "darkFantasy.png", "#25152d", "#5f315f"),
+        selector_card("background-btn-cyberpunk", "Cyberpunk", "You are a spellrunner in a neon city where old magic haunts new machines.", "cyberpunk.png", "#102438", "#2dd7d0"),
+        selector_card("background-btn-anime", "Anime", "You are a bright prodigy in a dramatic world of rival schools and impossible magic.", "anime.png", "#1f2452", "#ff8fd8"),
+    )
+    return "<div class='selector-grid'>" + "".join(cards) + "</div>"
+
+
+# Return HTML for image-backed school choices.
+def school_selector_html(world: str = "Dark Fantasy") -> str:
+    cards = tuple(selector_card(*card) for card in school_selector_cards(world))
+    return "<div class='selector-grid'>" + "".join(cards) + "</div>"
+
+
+# Return world-specific school selector card specs.
+def school_selector_cards(world: str) -> tuple[tuple[str, str, str, str, str, str], ...]:
+    slug = world_slug(world)
+    copy = school_selector_copy(slug)
+    return (
+        ("school-btn-fire", "Fire", copy["fire"], school_asset_name(slug, "fire"), "#351018", "#f06a2a"),
+        ("school-btn-ice", "Ice", copy["ice"], school_asset_name(slug, "ice"), "#102040", "#7ed9ff"),
+        ("school-btn-earth", "Earth", copy["earth"], school_asset_name(slug, "earth"), "#1d2d18", "#a5d46a"),
+    )
+
+
+# Return hover copy for school choices in one world.
+def school_selector_copy(slug: str) -> dict[str, str]:
+    if slug == "cyberpunk":
+        return {
+            "fire": "Burn through the neon grid with volatile heat, overclocked rituals, and delayed detonations.",
+            "ice": "Freeze signal, tempo, and nerve; win through clean timing and exposed weaknesses.",
+            "earth": "Raise concrete, steel, and old stone to bank pressure before the city breaks.",
+        }
+    if slug == "anime":
+        return {
+            "fire": "Fight like a rival prodigy: explosive pressure, bold finishers, and impossible sparks.",
+            "ice": "Move first, punish openings, and turn one perfect tempo beat into a burst.",
+            "earth": "Stand your ground, gather force, and answer with a dramatic shield-charged strike.",
+        }
+    return {
+        "fire": "Call ruinous flame in a lost kingdom: burn clocks, bombs, and violent finishers.",
+        "ice": "Bind the dark with frost, tempo, and precise strikes through brittle openings.",
+        "earth": "Wear the grave-stone crown: absorb the blow, bank force, and bury the boss.",
+    }
+
+
+# Return a stable asset slug for one world label.
+def world_slug(world: str) -> str:
+    return world.lower().replace(" ", "-")
+
+
+# Return the bundled image filename for a world-specific school.
+def school_asset_name(slug: str, school: str) -> str:
+    prefix = {"dark-fantasy": "darkFantasy", "cyberpunk": "cyberpunk", "anime": "anime"}[slug]
+    suffix = {"fire": "Fire", "ice": "Ice", "earth": "Earth"}[school]
+    if slug == "cyberpunk" and school == "ice":
+        return "cyberpunkice.png"
+    return f"{prefix}{suffix}.png"
+
+
+# Return one clickable visual selector card.
+def selector_card(button_id: str, label: str, copy: str, image: str, dark: str, accent: str) -> str:
+    uri = optional_asset_data_uri(image)
+    image_tag = f"<img class='selector-image' src='{uri}' alt=''>" if uri else ""
+    fallback = f"radial-gradient(circle at 50% 30%, {accent}, transparent 34%), linear-gradient(135deg, {dark}, #080512 82%)"
+    return (
+        f"<div class='selector-panel' onclick=\"tabrasClick('{button_id}')\" "
+        f"style='--selector-fallback:{fallback};'>"
+        f"{image_tag}"
+        f"<div class='selector-label'>{label}</div>"
+        f"<div class='selector-copy'>{copy}</div>"
+        "</div>"
+    )
+
+
+# Return the dedicated rules screen while deck generation runs.
+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>"
+        "<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>"
+        "</div></div>"
+    )
+
+
 # Return a typed school value.
 def school_as_literal(value: str) -> School:
     if value in {"fire", "ice", "earth"}:

art.py

@@ -0,0 +1,136 @@
+import base64
+import threading
+from dataclasses import dataclass, field, replace
+from io import BytesIO
+from typing import Any, Callable, Protocol, Sequence
+
+from budget import Card
+
+NEGATIVE_ART_PROMPT = (
+    "text, letters, words, labels, ui, interface, card frame, border, watermark, logo, "
+    "playing card, paper, white edge, cropped subject, cut off subject, split panel"
+)
+
+
+class ArtClient(Protocol):
+    # Return a browser-renderable image URI for one prompt.
+    def create_art(self, prompt: str) -> str:  # pragma: no cover
+        ...
+
+
+@dataclass
+class LazyArtClient:
+    loader: Callable[[], ArtClient]
+    lock: Any = field(default_factory=threading.Lock, repr=False, compare=False)
+    client: ArtClient | None = None
+
+    # Load the real art backend on first image request.
+    def create_art(self, prompt: str) -> str:
+        if self.client is None:
+            with self.lock:
+                if self.client is None:
+                    self.client = self.loader()
+        return self.client.create_art(prompt)
+
+
+@dataclass(frozen=True)
+class DiffusersImageClient:
+    pipe: Any
+    steps: int = 1
+    guidance_scale: float = 0.0
+    width: int = 512
+    height: int = 320
+    lock: Any = field(default_factory=threading.Lock, repr=False, compare=False)
+
+    # Generate one image and encode it as a data URI.
+    def create_art(self, prompt: str) -> str:
+        with self.lock:
+            result = self.pipe(
+                prompt=prompt,
+                num_inference_steps=self.steps,
+                guidance_scale=self.guidance_scale,
+                width=self.width,
+                height=self.height,
+                negative_prompt=NEGATIVE_ART_PROMPT,
+            )
+        return image_data_uri(result.images[0])
+
+    # Load a diffusers text-to-image pipeline.
+    @classmethod
+    def load(
+        cls,
+        model_id: str,
+        steps: int = 1,
+        guidance_scale: float = 0.0,
+        width: int = 512,
+        height: int = 320,
+    ) -> "DiffusersImageClient":  # pragma: no cover
+        import torch
+        from diffusers import AutoPipelineForText2Image
+
+        pipe = AutoPipelineForText2Image.from_pretrained(model_id, torch_dtype=best_torch_dtype(torch))
+        pipe.set_progress_bar_config(disable=True)
+        pipe = move_pipe_to_device(pipe, torch)
+        return cls(pipe, steps=steps, guidance_scale=guidance_scale, width=width, height=height)
+
+
+# Return the best local dtype for SDXL generation.
+def best_torch_dtype(torch: Any) -> Any:
+    if torch.cuda.is_available():
+        return torch.float16
+    if hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
+        return torch.float16
+    return torch.float32
+
+
+# Move a diffusers pipeline to the best available local device.
+def move_pipe_to_device(pipe: Any, torch: Any) -> Any:
+    if torch.cuda.is_available():
+        return pipe.to("cuda")
+    if hasattr(torch.backends, "mps") and torch.backends.mps.is_available():
+        return pipe.to("mps")
+    return pipe
+
+
+# Encode a PIL-like image as a PNG data URI.
+def image_data_uri(image: Any) -> str:
+    buffer = BytesIO()
+    image.save(buffer, format="PNG")
+    encoded = base64.b64encode(buffer.getvalue()).decode("ascii")
+    return f"data:image/png;base64,{encoded}"
+
+
+# Return the prompt sent to the art model for one card.
+def card_art_prompt(card: Card) -> str:
+    subject = card.art_prompt or f"{card.name}, {card.school} magic, {card.rules_text()}"
+    return (
+        f"{theme_style(card.theme)}, {subject}, "
+        "single dramatic spell scene, clear centered focal subject, full composition, no text, no card frame"
+    )
+
+
+# Return a visual style clause inferred from the user's world.
+def theme_style(theme: str) -> str:
+    lowered = theme.lower()
+    if "anime" in lowered:
+        return "wide anime fantasy key visual, cel shaded, clean linework, luminous color, dynamic composition"
+    if "dark" in lowered or "gothic" in lowered:
+        return "wide dark fantasy spell illustration, dramatic chiaroscuro, painterly concept art"
+    if "wuxia" in lowered:
+        return "wide wuxia fantasy spell illustration, flowing silk, ink-wash energy, cinematic motion"
+    return f"wide fantasy spell illustration, {theme}, painterly concept art"
+
+
+# Add generated art to one card, falling back to the unchanged card on failure.
+def illustrate_card(client: ArtClient | None, card: Card) -> Card:
+    if client is None:
+        return card
+    try:
+        return replace(card, art_uri=client.create_art(card_art_prompt(card)))
+    except Exception:
+        return card
+
+
+# Add generated art to a sequence of cards.
+def illustrate_cards(client: ArtClient | None, cards: Sequence[Card]) -> tuple[Card, ...]:
+    return tuple(illustrate_card(client, card) for card in cards)

budget.py

@@ -35,6 +35,7 @@ class Card:
     effects: tuple[Effect, ...]
     flavor: str = ""
     art_prompt: str = ""
+    art_uri: str = ""
 
     # Return fixed, parseable rules text for the card.
     def rules_text(self) -> str:

clients.py

@@ -1,5 +1,6 @@
 import os
 
+from art import ArtClient, DiffusersImageClient, LazyArtClient
 from boss import BossClient, NemotronBossClient
 from generator import CardPackClient, LlamaCppCardClient, MiniCPMCardClient
 from local_llm import (
@@ -20,6 +21,8 @@ DEFAULT_CARD_MODEL = "minicpm-v-4.6"
 DEFAULT_BOSS_MODEL = "nvidia/Nemotron-Mini-4B-Instruct"
 DEFAULT_MINICPM_MODEL = "openbmb/MiniCPM-V-4"
 DEFAULT_MLX_BOSS_MODEL = "mlx-community/Nemotron-Mini-4B-Instruct-4bit-mlx"
+DEFAULT_ART_MODEL = "stabilityai/sdxl-turbo"
+_art_client_cache: ArtClient | None = None
 
 
 # Build a card-generation client from environment variables.
@@ -31,7 +34,8 @@ def card_client_from_env() -> CardPackClient | None:
                 model=os.environ.get("TABRAS_CARD_MODEL", DEFAULT_CARD_MODEL),
                 timeout_seconds=int(os.environ.get("TABRAS_CARD_TIMEOUT", "60")),
                 temperature=float(os.environ.get("TABRAS_CARD_TEMPERATURE", "0.0")),
-                max_tokens=int(os.environ.get("TABRAS_CARD_MAX_TOKENS", "220")),
+                max_tokens=int(os.environ.get("TABRAS_CARD_MAX_TOKENS", "320")),
+                enable_thinking=False,
             )
         )
     if os.environ.get("TABRAS_CARD_BACKEND") == "transformers":
@@ -86,3 +90,26 @@ def boss_client_from_env() -> BossClient | None:
             temperature=float(os.environ.get("TABRAS_BOSS_TEMPERATURE", "0.2")),
         )
     )
+
+
+# Build an art-generation client from environment variables.
+def art_client_from_env() -> ArtClient | None:
+    global _art_client_cache
+    if os.environ.get("TABRAS_ART_BACKEND") != "diffusers":
+        return None
+    if _art_client_cache is None:
+        model_id = os.environ.get("TABRAS_ART_MODEL", DEFAULT_ART_MODEL)
+        steps = int(os.environ.get("TABRAS_ART_STEPS", "1"))
+        guidance_scale = float(os.environ.get("TABRAS_ART_GUIDANCE", "0.0"))
+        width = int(os.environ.get("TABRAS_ART_WIDTH", "512"))
+        height = int(os.environ.get("TABRAS_ART_HEIGHT", "320"))
+        _art_client_cache = LazyArtClient(
+            lambda: DiffusersImageClient.load(
+                model_id,
+                steps=steps,
+                guidance_scale=guidance_scale,
+                width=width,
+                height=height,
+            )
+        )
+    return _art_client_cache

forge.py

@@ -0,0 +1,61 @@
+import threading
+from concurrent.futures import Future, ThreadPoolExecutor
+from typing import Any, Callable, Hashable
+
+# Separate pools so each workload class runs without head-of-line blocking the others:
+# fast = player draft packs the user waits on; slow = the long boss-deck draft;
+# art = card illustration, kept off the slow lane so it never queues behind the boss deck.
+_executors = {
+    "fast": ThreadPoolExecutor(max_workers=3),
+    "slow": ThreadPoolExecutor(max_workers=1),
+    "art": ThreadPoolExecutor(max_workers=2),
+}
+_lock = threading.Lock()
+_jobs: dict[Hashable, Future] = {}
+_missing = object()
+
+
+# Submit one background job per key on its lane; lanes never starve one another.
+def submit(key: Hashable, fn: Callable[[], Any], lane: str = "fast") -> Future:
+    with _lock:
+        future = _jobs.get(key)
+        if future is None or (future.done() and future.exception() is not None):
+            executor = _executors.get(lane, _executors["fast"])
+            future = executor.submit(fn)
+            _jobs[key] = future
+        return future
+
+
+# Return a job result, computing inline when it was never prefetched.
+def take(key: Hashable, fn: Callable[[], Any]) -> Any:
+    return submit(key, fn).result()
+
+
+# Return a completed job result without blocking.
+def take_ready(key: Hashable, default: Any = _missing) -> Any:
+    with _lock:
+        future = _jobs.get(key)
+    if future is None or not future.done():
+        if default is _missing:
+            return None
+        return default
+    try:
+        return future.result()
+    except Exception:
+        if default is _missing:
+            return None
+        return default
+
+
+# Drop all cached jobs so a new run forges fresh cards.
+def reset() -> None:
+    with _lock:
+        _jobs.clear()
+
+
+# Block until every submitted job settles; used by tests.
+def drain() -> None:
+    with _lock:
+        futures = list(_jobs.values())
+    for future in futures:
+        future.exception()

generator.py

@@ -3,6 +3,7 @@ import json
 import subprocess
 import tempfile
 from collections import Counter
+from concurrent.futures import ThreadPoolExecutor
 from pathlib import Path
 from typing import Any, Protocol, Sequence
 
@@ -79,12 +80,13 @@ class LlamaCppCardClient:
     def create_card(self, payload: dict[str, Any]) -> dict[str, Any]:
         return generate_llamacpp_card(self.chat, payload, ())
 
-    # Return one raw card pack by generating single-card outputs.
+    # Return one raw card pack, generating the cards concurrently across
+    # llama-server slots, then de-duplicating names so no two picks collide.
     def create_pack(self, payload: dict[str, Any]) -> dict[str, Any]:
-        cards: list[dict[str, Any]] = []
-        for _ in range(int(payload.get("pack_size", 3))):
-            cards.append(generate_llamacpp_card(self.chat, payload, cards))
-        return {"cards": cards}
+        size = int(payload.get("pack_size", 3))
+        with ThreadPoolExecutor(max_workers=size) as pool:
+            cards = list(pool.map(lambda _: generate_llamacpp_card(self.chat, payload, ()), range(size)))
+        return {"cards": dedup_pack_names(cards)}
 
 
 TOOL_SCHEMA: dict[str, Any] = {
@@ -148,8 +150,11 @@ def generate_pack(
     cost: int,
     pack_size: int = 3,
     draft_anchors: Sequence[Card] = (),
+    quick: bool = False,
 ) -> tuple[Card, ...]:
-    raw = client.create_pack(pack_payload(school, theme, current_deck, cost, pack_size, draft_anchors))
+    payload = pack_payload(school, theme, current_deck, cost, pack_size, draft_anchors)
+    payload["quick"] = quick
+    raw = client.create_pack(payload)
     pack = parse_pack_payload(raw, school, theme, cost)
     if len(pack) < pack_size:
         raise ValueError("generated pack had the wrong size")
@@ -232,6 +237,8 @@ def codex_pack_prompt(payload: dict[str, Any]) -> str:
             "Do not include markdown, comments, or numeric magnitudes like damage/block/heal values.",
             "The engine owns all final numbers. You only choose primitive ids and weights.",
             "Make cards in the same response meaningfully different: vary primitive mixes, names, and tactical roles.",
+            "The flavor and art_prompt must describe the same concrete scene.",
+            "The art_prompt is for image generation: describe subject, setting, mood, and magic; never mention cards, frames, text, UI, or rules.",
             f"School: {payload['school']}",
             f"Theme: {payload['theme']}",
             f"Class identity: {payload['school_identity']}",
@@ -256,6 +263,71 @@ def card_system_prompt() -> str:
     return "You are Tabras card authoring logic. Output strict JSON only. No thinking. No markdown."
 
 
+NAME_BAN = (
+    "deal",
+    "damage",
+    "bomb",
+    "burn",
+    "block",
+    "draw",
+    "scaling",
+    "multi",
+    "hit",
+    "initiative",
+    "vulnerable",
+    "weak",
+    "ward",
+    "energy",
+    "pressure",
+    "clock",
+    "plan",
+    "tempo",
+    "payoff",
+    "fast",
+    "immediate",
+    "card",
+    "school",
+    "anime",
+    "fantasy",
+    "spell",
+)
+NAME_STEM_BAN = ("burn", "fast", "flam", "pressur")
+FALLBACK_NAMES: dict[str, tuple[str, ...]] = {
+    "fire": ("Cinder Warrant", "Ashen Oath", "Ember Brand", "Sable Pyre", "Charcoal Saint", "Red Sigil"),
+    "ice": ("Glass Edict", "Rime Mirror", "Pale Aurora", "Silver Stillness", "Needle Choir", "Blue Omen"),
+    "earth": ("Stone Covenant", "Cairn Writ", "Rootbound Seal", "Granite Vow", "Mossbound Relic", "Deep Warden"),
+}
+SCHOOL_FORBIDDEN_IMAGERY: dict[str, tuple[str, ...]] = {
+    "fire": ("glacier", "frost", "frozen", "ice", "snow", "winter", "blizzard", "earth"),
+    "ice": ("cinder", "ember", "flame", "inferno", "pyre", "ashen", "volcano", "fire", "earth"),
+    "earth": ("glacier", "frost", "inferno", "flame", "ember", "blizzard", "fire", "ice"),
+}
+
+
+# Return whether a card name is empty or leans on mechanic words.
+def generic_card_name(name: str) -> bool:
+    words = [word.strip(".,:;!?'\"").lower() for word in name.split()]
+    return not words or any(word in NAME_BAN or word.isdigit() or any(word.startswith(stem) for stem in NAME_STEM_BAN) for word in words)
+
+
+# Return the shared naming and flavor rules for card prompts.
+def naming_rules() -> tuple[str, ...]:
+    return (
+        "Name the card with one to three evocative English words of concrete imagery from the world's fantasy.",
+        f"Never use these words in the name: {', '.join(NAME_BAN)}.",
+        "Bad names repeat mechanics, like Fire Deal or Pressure Clock.",
+        "Write flavor as one short English in-world sentence with no mechanic or plan words.",
+    )
+
+
+# Return school-specific imagery constraints for prompts and validation.
+def school_imagery_rule(school: str) -> str:
+    forbidden = ", ".join(SCHOOL_FORBIDDEN_IMAGERY.get(school, ()))
+    if not forbidden:
+        return "Keep name, flavor, and art imagery aligned with the school."
+    return f"Do not use off-school imagery for {school}; avoid these words in name, flavor, and art_prompt: {forbidden}."
+
+
 # Build a compact one-card prompt for llama.cpp MiniCPM.
 def llamacpp_card_prompt(payload: dict[str, Any], pack_cards: Sequence[dict[str, Any]]) -> str:
     used_names = [card.get("name", "") for card in pack_cards]
@@ -267,7 +339,12 @@ def llamacpp_card_prompt(payload: dict[str, Any], pack_cards: Sequence[dict[str,
             "Shape: {\"name\": string, \"flavor\": string, \"art_prompt\": string, \"effects\": [{\"primitive_id\": string, \"weight\": 1}]}",
             "Use one or two effects. Do not write numeric damage, block, heal, or rules numbers.",
             "Fit the school identity, but invent the card's fantasy and tactical purpose freely.",
+            "Do not describe Fire as a people or species; use fast damage plan or pressure plan.",
             "Prefer a new tactical purpose over repeating the current deck or pack.",
+            "Make art_prompt match the flavor sentence as a concrete image scene.",
+            "The art_prompt must describe subject, setting, mood, and magic; never mention cards, frames, text, UI, or rules.",
+            *naming_rules(),
+            school_imagery_rule(str(payload["school"])),
             f"School: {payload['school']}",
             f"Theme: {payload['theme']}",
             f"Class identity: {payload['school_identity']}",
@@ -287,15 +364,27 @@ def llamacpp_card_prompt(payload: dict[str, Any], pack_cards: Sequence[dict[str,
     )
 
 
-# Generate one llama.cpp card with one corrective retry.
+# Generate one llama.cpp card with one corrective retry; quick mode takes the first card.
 def generate_llamacpp_card(chat: LocalChatClient, payload: dict[str, Any], pack_cards: Sequence[dict[str, Any]]) -> dict[str, Any]:
     prompt = llamacpp_card_prompt(payload, pack_cards)
-    card = parse_llamacpp_card_text(chat.complete(card_system_prompt(), prompt), payload, pack_cards)
+    card = parse_llamacpp_card_text(chat.complete(card_system_prompt(), prompt), payload, pack_cards, discard_bad_text=False)
     need = llama_candidate_need(payload, pack_summary(pack_cards))
-    if card_satisfies_candidate_need(card, need):
+    if payload.get("quick"):
+        return repair_llamacpp_card(card, payload, pack_cards)
+    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)
-    return retry if card_satisfies_candidate_need(retry, need) else 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)
+
+
+# Return whether a generated card meets its need with a non-generic name.
+def card_acceptable(card: dict[str, Any], need: str, payload: dict[str, Any]) -> bool:
+    return (
+        card_satisfies_candidate_need(card, need)
+        and not generic_card_name(str(card.get("name", "")))
+        and not theme_name_leak(str(card.get("name", "")), str(payload["theme"]))
+        and not school_flavor_mismatch(str(payload["school"]), card)
+    )
 
 
 # Build a corrective prompt for a missed candidate need.
@@ -304,6 +393,10 @@ def llamacpp_retry_prompt(payload: dict[str, Any], need: str) -> str:
         (
             "Create exactly one corrected Tabras card as JSON.",
             "Shape: {\"name\": string, \"flavor\": string, \"art_prompt\": string, \"effects\": [{\"primitive_id\": string, \"weight\": 1}]}",
+            "Make flavor and art_prompt describe the same concrete scene.",
+            "The art_prompt must describe an image scene only; no cards, text, frames, UI, or rules.",
+            *naming_rules(),
+            school_imagery_rule(str(payload["school"])),
             f"School: {payload['school']}",
             f"Theme: {payload['theme']}",
             f"Allowed primitive_id values: {json.dumps(payload['allowed_primitives'])}",
@@ -312,6 +405,9 @@ def llamacpp_retry_prompt(payload: dict[str, Any], need: str) -> str:
             "If the requirement mentions primitive_id scaling, include an effect with primitive_id exactly \"scaling\".",
             "If the requirement mentions primitive_id multi_hit, include an effect with primitive_id exactly \"multi_hit\".",
             "If the requirement mentions primitive_id initiative, include an effect with primitive_id exactly \"initiative\".",
+            "If the requirement mentions primitive_id burn, include an effect with primitive_id exactly \"burn\".",
+            "If the requirement mentions primitive_id bomb, include an effect with primitive_id exactly \"bomb\".",
+            "If the requirement mentions primitive_id draw, include an effect with primitive_id exactly \"draw\".",
             "JSON only.",
         )
     )
@@ -402,6 +498,13 @@ def earth_anchor_direction(counts: dict[str, int]) -> str:
 # Return a per-candidate need for one-card llama.cpp generation.
 def llama_candidate_need(payload: dict[str, Any], pack_counts: dict[str, int]) -> str:
     draft_need_text = str(payload["draft_need"]).lower()
+    school = str(payload["school"])
+    if school == "fire" and pack_counts.get("deal", 0) > 0 and pack_counts.get("burn", 0) == 0:
+        return "explore primitive_id burn so this pack is not another direct damage card."
+    if school == "fire" and pack_counts.get("deal", 0) > 0 and pack_counts.get("bomb", 0) == 0:
+        return "explore primitive_id bomb so this pack has delayed pressure."
+    if school == "fire" and pack_counts.get("deal", 0) > 0 and pack_counts.get("draw", 0) == 0:
+        return "explore primitive_id draw as support instead of another direct damage card."
     if "add block" in draft_need_text and pack_counts.get("block", 0) == 0:
         return "explore primitive_id block as the shield-charge engine while inventing the card fantasy freely."
     if "scaling" in draft_need_text and pack_counts.get("scaling", 0) == 0:
@@ -427,11 +530,24 @@ def card_satisfies_candidate_need(card: dict[str, Any], need: str) -> bool:
         return "multi_hit" in primitives
     if "primitive_id initiative" in need:
         return "initiative" in primitives
+    if "primitive_id burn" in need:
+        return "burn" in primitives
+    if "primitive_id bomb" in need:
+        return "bomb" in primitives
+    if "primitive_id draw" in need:
+        return "draw" in primitives
     if "avoid another primary deal" in need:
         return not primitives or primitives[0] != "deal"
     return True
 
 
+# Build a minimal raw response that satisfies a missed primitive need.
+def fallback_raw_for_need(need: str, payload: dict[str, Any]) -> dict[str, Any]:
+    allowed = tuple(payload["allowed_primitives"])
+    primitive = next((candidate for candidate in allowed if f"primitive_id {candidate}" in need), allowed[0])
+    return {"effects": [{"primitive_id": primitive, "weight": 1}]}
+
+
 # Count primitive ids represented in a costed deck.
 def deck_summary(deck: Sequence[Card]) -> dict[str, int]:
     counts: Counter[str] = Counter()
@@ -485,7 +601,7 @@ def fire_draft_need(counts: dict[str, int]) -> str:
         return "Delayed damage is covered; prefer immediate deal, scaling finishers, draw, or energy."
     if counts.get("deal", 0) == 0:
         return "Add immediate deal so Fire can race before delayed damage resolves."
-    return "Add a distinct pressure card that advances Fire's race plan."
+    return "Add a distinct pressure card that advances Fire's fast damage plan."
 
 
 # Return an Ice-specific drafting need.
@@ -548,19 +664,31 @@ def normalize_card_response(raw: dict[str, Any]) -> dict[str, Any]:
 
 
 # Parse one llama.cpp card response, falling back on malformed JSON.
-def parse_llamacpp_card_text(text: str, payload: dict[str, Any], pack_cards: Sequence[dict[str, Any]]) -> dict[str, Any]:
+def parse_llamacpp_card_text(
+    text: str,
+    payload: dict[str, Any],
+    pack_cards: Sequence[dict[str, Any]],
+    discard_bad_text: bool = True,
+) -> dict[str, Any]:
     try:
         raw = normalize_card_response(json.loads(extract_json_object(text)))
     except (TypeError, ValueError, json.JSONDecodeError):
         raw = {}
-    return repair_llamacpp_card(raw, payload, pack_cards)
+    return repair_llamacpp_card(raw, payload, pack_cards, discard_bad_text)
 
 
 # Repair cheap llama.cpp JSON into the strict card schema.
-def repair_llamacpp_card(raw: dict[str, Any], payload: dict[str, Any], pack_cards: Sequence[dict[str, Any]]) -> dict[str, Any]:
+def repair_llamacpp_card(
+    raw: dict[str, Any],
+    payload: dict[str, Any],
+    pack_cards: Sequence[dict[str, Any]],
+    discard_bad_text: bool = True,
+) -> dict[str, Any]:
     allowed = tuple(payload["allowed_primitives"])
     effects = repair_effects(raw.get("effects"), allowed)
-    name = str(raw.get("name") or fallback_card_name(payload["school"], effects, pack_cards))
+    if discard_bad_text and unusable_raw_card(raw, payload):
+        raw = {}
+    name = unique_card_name(str(raw.get("name") or fallback_card_name(payload["school"], effects, pack_cards)), pack_cards)
     return {
         "name": name,
         "flavor": str(raw.get("flavor", "")),
@@ -569,6 +697,50 @@ def repair_llamacpp_card(raw: dict[str, Any], payload: dict[str, Any], pack_card
     }
 
 
+# Return whether generated text leans into another school's imagery.
+def school_flavor_mismatch(school: str, raw: dict[str, Any]) -> bool:
+    text = " ".join(str(raw.get(key, "")) for key in ("name", "flavor", "art_prompt")).lower()
+    words = {word.strip(".,:;!?'\"").lower() for word in text.split()}
+    return any(word in words for word in SCHOOL_FORBIDDEN_IMAGERY.get(school, ()))
+
+
+# Return whether raw model text must be discarded before repair.
+def unusable_raw_card(raw: dict[str, Any], payload: dict[str, Any]) -> bool:
+    name = str(raw.get("name", ""))
+    return (
+        generic_card_name(name)
+        or theme_name_leak(name, str(payload["theme"]))
+        or school_flavor_mismatch(str(payload["school"]), raw)
+    )
+
+
+# Return whether the name leaks meta theme labels instead of in-world imagery.
+def theme_name_leak(name: str, theme: str) -> bool:
+    name_words = {word.strip(".,:;!?'\"").lower() for word in name.split()}
+    theme_words = {word.strip(".,:;!?'\"").lower() for word in theme.split()}
+    return any(word in name_words for word in theme_words if word in {"anime", "fantasy", "wuxia", "school", "world"})
+
+
+# Rename duplicate names so every pick in a parallel-built pack stays distinct.
+def dedup_pack_names(cards: list[dict[str, Any]]) -> list[dict[str, Any]]:
+    seen: list[dict[str, Any]] = []
+    for card in cards:
+        card["name"] = unique_card_name(str(card.get("name", "")), seen)
+        seen.append(card)
+    return cards
+
+
+# Return a card name that does not duplicate earlier cards in the pack.
+def unique_card_name(name: str, pack_cards: Sequence[dict[str, Any]]) -> str:
+    used = {str(card.get("name", "")) for card in pack_cards}
+    if name not in used:
+        return name
+    index = 2
+    while f"{name} {index}" in used:
+        index += 1
+    return f"{name} {index}"
+
+
 # Repair a model-authored effect list to allowed primitive ids.
 def repair_effects(raw: Any, allowed: Sequence[str]) -> list[dict[str, Any]]:
     effects = [effect for effect in raw if isinstance(effect, dict)] if isinstance(raw, list) else []
@@ -585,10 +757,10 @@ def repair_effect(raw: dict[str, Any], allowed: Sequence[str]) -> dict[str, Any]
 # Build a deterministic fallback card name.
 def fallback_card_name(school: str, effects: Sequence[dict[str, Any]], pack_cards: Sequence[dict[str, Any]]) -> str:
     used = {str(card.get("name", "")) for card in pack_cards}
-    base = f"{school.title()} {' '.join(str(effect['primitive_id']).title() for effect in effects)}".strip()
-    if base not in used:
-        return base
-    return f"{base} {len(used) + 1}"
+    for name in FALLBACK_NAMES.get(school, FALLBACK_NAMES["fire"]):
+        if name not in used:
+            return name
+    return f"{FALLBACK_NAMES.get(school, FALLBACK_NAMES['fire'])[0]} {len(used) + 1}"
 
 
 # Build fallback art text when the model omits it.

local_llm.py

@@ -13,10 +13,11 @@ class LocalChatClient:
     timeout_seconds: int = 60
     temperature: float = 0.2
     max_tokens: int = 256
+    enable_thinking: bool | None = None
 
     # Complete one chat prompt through an OpenAI-compatible local endpoint.
     def complete(self, system: str, user: str) -> str:
-        payload = chat_payload(self.model, system, user, self.temperature, self.max_tokens)
+        payload = chat_payload(self.model, system, user, self.temperature, self.max_tokens, self.enable_thinking)
         req = request.Request(
             self.endpoint,
             data=json.dumps(payload).encode("utf-8"),
@@ -175,7 +176,14 @@ class MiniCPMTransformersChatClient:
 
 
 # Build an OpenAI-compatible chat completion payload.
-def chat_payload(model: str, system: str, user: str, temperature: float, max_tokens: int | None = None) -> dict[str, Any]:
+def chat_payload(
+    model: str,
+    system: str,
+    user: str,
+    temperature: float,
+    max_tokens: int | None = None,
+    enable_thinking: bool | None = None,
+) -> dict[str, Any]:
     payload = {
         "model": model,
         "messages": [
@@ -186,6 +194,8 @@ def chat_payload(model: str, system: str, user: str, temperature: float, max_tok
     }
     if max_tokens is not None:
         payload["max_tokens"] = max_tokens
+    if enable_thinking is not None:
+        payload["chat_template_kwargs"] = {"enable_thinking": enable_thinking}
     return payload
 
 

pyproject.toml

@@ -3,7 +3,7 @@ testpaths = ["tests"]
 
 [tool.coverage.run]
 branch = true
-source = ["ai_runtime", "boss", "budget", "clients", "draft", "game", "generator", "local_llm", "play", "primitives"]
+source = ["ai_runtime", "art", "boss", "budget", "clients", "draft", "forge", "game", "generator", "local_llm", "play", "primitives"]
 
 [tool.coverage.report]
 show_missing = true

requirements.txt

@@ -0,0 +1,7 @@
+gradio
+diffusers
+torch
+transformers
+accelerate
+safetensors
+pillow

tests/test_ai_runtime.py

@@ -15,6 +15,7 @@ def test_minicpm_server_command() -> None:
     assert "--port" in command
     assert "9000" in command
     assert "--n-gpu-layers" in command
+    assert "--parallel" in command
 
 
 # Verify local AI env forces MiniCPM card generation and Nemotron boss play.
@@ -23,9 +24,15 @@ def test_local_ai_env(monkeypatch) -> None:
     env = local_ai_env(9001)
     assert env["TABRAS_CARD_BACKEND"] == "llamacpp"
     assert env["TABRAS_CARD_ENDPOINT"] == "http://127.0.0.1:9001/v1/chat/completions"
+    assert env["TABRAS_CARD_MAX_TOKENS"] == "192"
+    assert env["TABRAS_CARD_TEMPERATURE"] == "0.7"
     assert env["TABRAS_AI_BOSS"] == "1"
     assert env["TABRAS_BOSS_BACKEND"] == "mlx"
     assert "Nemotron" in env["TABRAS_BOSS_MODEL"]
+    assert env["TABRAS_ART_BACKEND"] == "diffusers"
+    assert env["TABRAS_ART_MODEL"] == "stabilityai/sdxl-turbo"
+    assert env["TABRAS_ART_WIDTH"] == "512"
+    assert env["TABRAS_ART_HEIGHT"] == "320"
 
 
 # Verify starting MiniCPM fails early when the GGUF is absent.

tests/test_app.py

@@ -0,0 +1,147 @@
+import forge
+from app import (
+    CSS,
+    background_selector_html,
+    refresh_screen,
+    school_asset_name,
+    school_selector_html,
+    show_background,
+    show_draft_from_rules,
+    show_name,
+    show_school,
+    start_rules,
+)
+from ui import new_run_shell
+
+
+class AppPackClient:
+    # Return one deterministic draft pack for app-flow tests.
+    def __init__(self) -> None:
+        self.calls = 0
+
+    # Return a three-card model payload.
+    def create_pack(self, payload):
+        self.calls += 1
+        card = lambda index: {
+            "name": f"Flow Card {self.calls}-{index}",
+            "flavor": "The table waits.",
+            "art_prompt": "glowing spell on a wooden desk",
+            "effects": [{"primitive_id": "deal", "weight": 1}],
+        }
+        return {"cards": [card(index) for index in range(payload["pack_size"])]}
+
+
+class AppArtClient:
+    # Count image requests made after card text is forged.
+    def __init__(self) -> None:
+        self.calls = 0
+
+    # Return a deterministic image URI.
+    def create_art(self, prompt: str) -> str:
+        self.calls += 1
+        return f"uri:{prompt}"
+
+
+# Verify setup advances through one prompt per screen.
+def test_setup_screen_steps() -> None:
+    assert show_name()[1] == "name"
+    assert show_background()[1] == "background"
+    assert show_school()[1] == "school"
+
+
+# Verify the title CTA stays compact instead of full-width.
+def test_play_now_button_is_compact() -> None:
+    assert "#play-now-btn" in CSS
+    assert "max-width: 220px" in CSS
+    assert "#start-draft-btn" in CSS
+    assert "max-width: 200px" in CSS
+
+
+# Verify draft cards are compact enough for the draft table.
+def test_draft_cards_are_compact() -> None:
+    assert "minmax(0, 300px)" in CSS
+    assert "min-height: 405px" in CSS
+
+
+# Verify setup selectors are image-backed clickable panels with hover copy.
+def test_setup_selectors_use_image_panels() -> None:
+    background = background_selector_html()
+    school = school_selector_html()
+    assert "selector-panel" in background
+    assert "selector-image" in background
+    assert "selector-copy" in background
+    assert "background-btn-dark-fantasy" in background
+    assert "You are a mage" in background
+    assert "school-btn-fire" in school
+    assert "school-btn-ice" in school
+    assert "school-btn-earth" in school
+
+
+# Verify selector art resolves to the bundled user-provided filenames.
+def test_setup_selectors_use_bundled_assets() -> None:
+    background = background_selector_html()
+
+    assert "data:image/png;base64" in background
+    assert school_asset_name("dark-fantasy", "fire") == "darkFantasyFire.png"
+    assert school_asset_name("dark-fantasy", "ice") == "darkFantasyIce.png"
+    assert school_asset_name("dark-fantasy", "earth") == "darkFantasyEarth.png"
+    assert school_asset_name("cyberpunk", "fire") == "cyberpunkFire.png"
+    assert school_asset_name("cyberpunk", "ice") == "cyberpunkice.png"
+    assert school_asset_name("cyberpunk", "earth") == "cyberpunkEarth.png"
+    assert school_asset_name("anime", "fire") == "animeFire.png"
+    assert school_asset_name("anime", "ice") == "animeIce.png"
+    assert school_asset_name("anime", "earth") == "animeEarth.png"
+    assert "data:image/png;base64" in school_selector_html("Cyberpunk")
+
+
+# Verify the rules screen starts deck generation in the background.
+def test_start_rules_queues_deck_generation(monkeypatch) -> None:
+    forge.reset()
+    client = AppPackClient()
+    monkeypatch.setattr("app.card_client_from_env", lambda: client)
+    monkeypatch.setattr("app.art_client_from_env", lambda: None)
+
+    output = start_rules("Ada", "ice", "Anime")
+    state = output[0]
+
+    assert output[1] == "rules"
+    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]
+
+    forge.drain()
+    refresh_screen(state, "rules")
+    assert client.calls > 0
+
+
+# Verify the rules screen starts image work once card text is ready.
+def test_rules_screen_starts_art_generation(monkeypatch) -> None:
+    forge.reset()
+    client = AppPackClient()
+    art_client = AppArtClient()
+    monkeypatch.setattr("app.card_client_from_env", lambda: client)
+    monkeypatch.setattr("app.art_client_from_env", lambda: art_client)
+
+    state = start_rules("Ada", "fire", "Cyberpunk")[0]
+    forge.drain()
+    state = refresh_screen(state, "rules")[0]
+    forge.drain()
+    refresh_screen(state, "rules")
+
+    assert art_client.calls >= 3
+
+
+# Verify skipping rules shows a deck-loading draft state if the pack is still pending.
+def test_skip_rules_shows_loading_deck(monkeypatch) -> None:
+    forge.reset()
+    monkeypatch.setattr("app.card_client_from_env", lambda: None)
+    monkeypatch.setattr("app.art_client_from_env", lambda: None)
+
+    state = new_run_shell("Ada", "Anime", "fire", seed=1)
+    output = show_draft_from_rules(state)
+
+    assert output[1] == "draft"
+    assert output[0].loading == "Loading your deck"
+    assert "Loading your deck" in output[10]

tests/test_art.py

@@ -0,0 +1,121 @@
+from io import BytesIO
+
+from PIL import Image
+
+from art import (
+    DiffusersImageClient,
+    best_torch_dtype,
+    card_art_prompt,
+    illustrate_card,
+    illustrate_cards,
+    image_data_uri,
+    move_pipe_to_device,
+    theme_style,
+)
+from budget import Card
+from primitives import Effect
+
+
+class FakeArtClient:
+    # Return a deterministic image URI for prompts.
+    def create_art(self, prompt: str) -> str:
+        return f"uri:{prompt}"
+
+
+class BrokenArtClient:
+    # Raise like a failing image backend.
+    def create_art(self, prompt: str) -> str:
+        raise RuntimeError("no art")
+
+
+class FakePipe:
+    # Capture pipeline calls and return a PIL image.
+    def __init__(self) -> None:
+        self.calls = []
+        self.device = ""
+
+    def __call__(self, **kwargs):
+        self.calls.append(kwargs)
+        return type("Result", (), {"images": [Image.new("RGB", (2, 2), "red")]})()
+
+    def to(self, device: str):
+        self.device = device
+        return self
+
+
+class FakeTorch:
+    float16 = "f16"
+    float32 = "f32"
+
+    class cuda:
+        # Report CUDA as unavailable.
+        @staticmethod
+        def is_available() -> bool:
+            return False
+
+    class backends:
+        class mps:
+            # Report MPS as available.
+            @staticmethod
+            def is_available() -> bool:
+                return True
+
+
+# Verify images are encoded as browser-renderable PNG data URIs.
+def test_image_data_uri() -> None:
+    uri = image_data_uri(Image.new("RGB", (1, 1), "blue"))
+    assert uri.startswith("data:image/png;base64,")
+
+
+# Verify diffusers image client calls the pipeline and returns encoded art.
+def test_diffusers_image_client_create_art() -> None:
+    pipe = FakePipe()
+    client = DiffusersImageClient(pipe, steps=1, width=64, height=64)
+    uri = client.create_art("dark spell")
+    assert uri.startswith("data:image/png;base64,")
+    assert pipe.calls[0]["prompt"] == "dark spell"
+    assert pipe.calls[0]["num_inference_steps"] == 1
+    assert pipe.calls[0]["width"] == 64
+    assert "text" in pipe.calls[0]["negative_prompt"]
+
+
+# Verify dtype and device helpers prefer MPS when CUDA is unavailable.
+def test_torch_helpers() -> None:
+    pipe = FakePipe()
+    assert best_torch_dtype(FakeTorch) == "f16"
+    assert move_pipe_to_device(pipe, FakeTorch) is pipe
+    assert pipe.device == "mps"
+
+
+# Verify card prompts use model-authored art prompts first.
+def test_card_art_prompt() -> None:
+    card = Card("Spark", 1, "fire", "wuxia", (Effect("deal", amount=2),), art_prompt="ember saint")
+    assert "ember saint" in card_art_prompt(card)
+    assert "no text" in card_art_prompt(card)
+    fallback = Card("Spark", 1, "fire", "wuxia", (Effect("deal", amount=2),))
+    prompt = card_art_prompt(fallback)
+    assert "Spark" in prompt
+    assert "Deal 2 damage." in prompt
+    assert "wide wuxia fantasy spell illustration" in prompt
+
+
+# Verify user worlds become concrete visual style clauses.
+def test_theme_style() -> None:
+    assert "anime fantasy key visual" in theme_style("Anime")
+    assert "dark fantasy spell illustration" in theme_style("dark fantasy")
+
+
+# Verify illustration attaches generated art without changing card rules.
+def test_illustrate_card() -> None:
+    card = Card("Spark", 1, "fire", "wuxia", (Effect("deal", amount=2),), art_prompt="ember")
+    illustrated = illustrate_card(FakeArtClient(), card)
+    assert illustrated.art_uri.startswith("uri:wide wuxia fantasy spell illustration")
+    assert illustrated.rules_text() == card.rules_text()
+    assert illustrate_card(None, card) is card
+    assert illustrate_card(BrokenArtClient(), card) is card
+
+
+# Verify illustration maps across packs.
+def test_illustrate_cards() -> None:
+    cards = (Card("Spark", 1, "fire", "wuxia", (Effect("deal", amount=2),), art_prompt="ember"),)
+    assert illustrate_cards(FakeArtClient(), cards)[0].art_uri.startswith("uri:wide wuxia")

tests/test_clients.py

@@ -1,4 +1,5 @@
-from clients import boss_client_from_env, card_client_from_env
+from clients import art_client_from_env, boss_client_from_env, card_client_from_env
+from art import DiffusersImageClient, LazyArtClient
 from boss import NemotronBossClient
 from generator import LlamaCppCardClient, MiniCPMCardClient
 from local_llm import LocalChatClient, LocalCompletionClient, nemotron_prompt
@@ -10,6 +11,12 @@ class FakeChat:
         return "{}"
 
 
+class FakeArtBackend:
+    # Return a deterministic image URI.
+    def create_art(self, prompt: str) -> str:
+        return f"uri:{prompt}"
+
+
 # Verify card client is disabled without an endpoint.
 def test_card_client_from_env_disabled(monkeypatch) -> None:
     monkeypatch.delenv("TABRAS_CARD_ENDPOINT", raising=False)
@@ -46,7 +53,8 @@ def test_card_client_from_env_llamacpp(monkeypatch) -> None:
     assert isinstance(client.chat, LocalChatClient)
     assert client.chat.endpoint == "http://cards"
     assert client.chat.model == "mini-q4"
-    assert client.chat.max_tokens == 220
+    assert client.chat.max_tokens == 320
+    assert client.chat.enable_thinking is False
 
 
 # Verify boss client is disabled unless enabled.
@@ -98,3 +106,58 @@ def test_boss_client_from_env_mlx(monkeypatch) -> None:
     client = boss_client_from_env()
     assert isinstance(client, NemotronBossClient)
     assert isinstance(client.chat, FakeChat)
+
+
+# Verify art client is disabled unless explicitly enabled.
+def test_art_client_from_env_disabled(monkeypatch) -> None:
+    monkeypatch.delenv("TABRAS_ART_BACKEND", raising=False)
+    monkeypatch.setattr("clients._art_client_cache", None)
+    assert art_client_from_env() is None
+
+
+# Verify art client loads and caches the SD-Turbo diffusers backend.
+def test_art_client_from_env_diffusers(monkeypatch) -> None:
+    monkeypatch.setenv("TABRAS_ART_BACKEND", "diffusers")
+    monkeypatch.setenv("TABRAS_ART_MODEL", "sdxl-local")
+    monkeypatch.setenv("TABRAS_ART_STEPS", "1")
+    monkeypatch.setenv("TABRAS_ART_WIDTH", "128")
+    monkeypatch.setenv("TABRAS_ART_HEIGHT", "96")
+    monkeypatch.setattr("clients._art_client_cache", None)
+
+    calls = []
+
+    def fake_load(model_id: str, **kwargs):
+        calls.append(model_id)
+        assert model_id == "sdxl-local"
+        assert kwargs["steps"] == 1
+        assert kwargs["width"] == 128
+        assert kwargs["height"] == 96
+        return FakeArtBackend()
+
+    monkeypatch.setattr(DiffusersImageClient, "load", staticmethod(fake_load))
+    client = art_client_from_env()
+    assert isinstance(client, LazyArtClient)
+    assert art_client_from_env() is client
+    assert calls == []
+    assert client.create_art("spell") == "uri:spell"
+    assert calls == ["sdxl-local"]
+
+
+# Verify art client defaults use the lazy SDXL-Turbo backend.
+def test_art_client_from_env_fast_defaults(monkeypatch) -> None:
+    monkeypatch.setenv("TABRAS_ART_BACKEND", "diffusers")
+    monkeypatch.delenv("TABRAS_ART_MODEL", raising=False)
+    monkeypatch.delenv("TABRAS_ART_STEPS", raising=False)
+    monkeypatch.delenv("TABRAS_ART_WIDTH", raising=False)
+    monkeypatch.delenv("TABRAS_ART_HEIGHT", raising=False)
+    monkeypatch.setattr("clients._art_client_cache", None)
+
+    def fake_load(model_id: str, **kwargs):
+        assert model_id == "stabilityai/sdxl-turbo"
+        assert kwargs["steps"] == 1
+        assert kwargs["width"] == 512
+        assert kwargs["height"] == 320
+        return FakeArtBackend()
+
+    monkeypatch.setattr(DiffusersImageClient, "load", staticmethod(fake_load))
+    assert art_client_from_env().create_art("spark") == "uri:spark"

tests/test_forge.py

@@ -0,0 +1,47 @@
+import forge
+
+
+# Verify identical keys reuse one background job.
+def test_submit_dedupes_by_key() -> None:
+    forge.reset()
+    calls: list[int] = []
+    future = forge.submit("k", lambda: calls.append(1) or "a")
+    assert forge.submit("k", lambda: calls.append(1) or "b") is future
+    forge.drain()
+    assert calls == [1]
+
+
+# Verify take computes inline when never prefetched and reuses results after.
+def test_take_computes_and_caches() -> None:
+    forge.reset()
+    assert forge.take("pack", lambda: "fresh") == "fresh"
+    assert forge.take("pack", lambda: "other") == "fresh"
+
+
+# Verify take_ready polls completed jobs without blocking.
+def test_take_ready_polls_completed_jobs() -> None:
+    forge.reset()
+    assert forge.take_ready("missing", "empty") == "empty"
+    forge.submit("art", lambda: "ready")
+    forge.drain()
+    assert forge.take_ready("art", "empty") == "ready"
+
+
+# Verify failed jobs are resubmitted on the next request.
+def test_failed_jobs_resubmit() -> None:
+    forge.reset()
+
+    def boom() -> str:
+        raise RuntimeError("nope")
+
+    forge.submit("x", boom)
+    forge.drain()
+    assert forge.take("x", lambda: "recovered") == "recovered"
+
+
+# Verify slow-lane jobs share the same key cache as fast-lane jobs.
+def test_slow_lane_shares_key_cache() -> None:
+    forge.reset()
+    future = forge.submit("slow-key", lambda: "art", lane="slow")
+    assert forge.submit("slow-key", lambda: "other") is future
+    assert forge.take("slow-key", lambda: "other") == "art"

tests/test_generator.py

@@ -18,6 +18,7 @@ from generator import (
     generate_card,
     generate_pack,
     generate_llamacpp_card,
+    generic_card_name,
     generator_payload,
     llamacpp_card_prompt,
     llama_candidate_need,
@@ -30,7 +31,11 @@ from generator import (
     parse_pack_payload,
     repair_llamacpp_card,
     primitive_guidance,
+    school_flavor_mismatch,
+    school_imagery_rule,
     school_identity,
+    theme_name_leak,
+    unique_card_name,
 )
 from primitives import Effect
 
@@ -159,6 +164,14 @@ def test_llama_candidate_need_avoids_repeated_deal() -> None:
     assert "primitive_id block" in llama_candidate_need(payload, {"deal": 1, "scaling": 1})
 
 
+# Verify Fire pack generation explores non-deal primitives after one damage card.
+def test_llama_candidate_need_diversifies_fire_pack() -> None:
+    payload = pack_payload("fire", "wuxia", [], 2, 3)
+    assert "primitive_id burn" in llama_candidate_need(payload, {"deal": 1})
+    assert "primitive_id bomb" in llama_candidate_need(payload, {"deal": 1, "burn": 1})
+    assert "primitive_id draw" in llama_candidate_need(payload, {"deal": 1, "burn": 1, "bomb": 1})
+
+
 # Verify llama.cpp retry prompt names exact primitive requirements.
 def test_llamacpp_retry_prompt_mentions_scaling() -> None:
     payload = pack_payload("earth", "wuxia", [], 2, 3)
@@ -458,16 +471,18 @@ def test_llamacpp_card_prompt() -> None:
     assert "Current draft need" in prompt
     assert "This candidate should" in prompt
     assert "Already in this pack" in prompt
+    assert "race plan" not in prompt
     assert "\"burn\": 1" in prompt
     assert "Spark" in prompt
 
 
-# Verify llama.cpp card client assembles packs from single-card calls.
+# Verify llama.cpp card client builds packs from concurrent single-card calls,
+# one model call per card, with duplicate names de-duplicated after the fact.
 def test_llamacpp_card_client() -> None:
     chat = FakeChat('{"name": "A", "effects": [{"primitive_id": "deal"}]}')
     client = LlamaCppCardClient(chat)  # type: ignore[arg-type]
     raw = client.create_pack(pack_payload("fire", "wuxia", [], 1, 3))
-    assert [card["name"] for card in raw["cards"]] == ["A", "A", "A"]
+    assert [card["name"] for card in raw["cards"]] == ["A", "A 2", "A 3"]
     assert len(chat.calls) == 3
 
 
@@ -477,26 +492,134 @@ def test_generate_llamacpp_card_retries_missed_need() -> None:
     chat = FakeChat(
         [
             '{"name": "Plain", "effects": [{"primitive_id": "deal"}]}',
-            '{"earth_tabras": {"name": "Payoff", "effects": [{"primitive_id": "scaling"}]}}',
+            '{"earth_tabras": {"name": "Granite Vow", "effects": [{"primitive_id": "scaling"}]}}',
         ]
     )
     card = generate_llamacpp_card(chat, payload, [])
-    assert card["name"] == "Payoff"
+    assert card["name"] == "Granite Vow"
     assert card["effects"] == [{"primitive_id": "scaling", "weight": 1}]
     assert len(chat.calls) == 2
 
 
+# Verify generic name detection flags mechanic words and empty names.
+def test_generic_card_name() -> None:
+    assert generic_card_name("")
+    assert generic_card_name("Fire Deal")
+    assert generic_card_name("Ice Deal 2")
+    assert generic_card_name("Vulnerable Anime School")
+    assert generic_card_name("Fast Burner")
+    assert generic_card_name("Flaming Fire")
+    assert generic_card_name("Pressureflare")
+    assert generic_card_name("Pressure Clock 2")
+    assert not generic_card_name("Vow of Cinders")
+
+
+# Verify theme labels are rejected from in-world card names.
+def test_theme_name_leak() -> None:
+    assert theme_name_leak("Vulnerable Anime School", "anime school")
+    assert not theme_name_leak("Glass Edict", "anime school")
+
+
+# Verify card prompts carry the naming rules.
+def test_prompts_ban_mechanic_names() -> None:
+    payload = pack_payload("fire", "wuxia", [], 2, 3)
+    assert "Never use these words in the name" in llamacpp_card_prompt(payload, [])
+    assert "Never use these words in the name" in llamacpp_retry_prompt(payload, "fit the draft need")
+    assert "glacier" in school_imagery_rule("fire")
+    assert "glacier" in llamacpp_card_prompt(payload, [])
+
+
+# Verify llama.cpp card generation retries hyper-generic names.
+def test_generate_llamacpp_card_retries_generic_name() -> None:
+    payload = pack_payload("fire", "wuxia", [], 2, 3)
+    chat = FakeChat(
+        [
+            '{"name": "Fire Deal", "effects": [{"primitive_id": "deal"}]}',
+            '{"name": "Vow of Cinders", "effects": [{"primitive_id": "deal"}]}',
+        ]
+    )
+    card = generate_llamacpp_card(chat, payload, [])
+    assert card["name"] == "Vow of Cinders"
+    assert len(chat.calls) == 2
+
+
+# Verify failed Fire retries repair to a non-deal primitive when pack needs variety.
+def test_generate_llamacpp_card_repairs_to_needed_fire_primitive() -> None:
+    payload = pack_payload("fire", "wuxia", [], 2, 3)
+    chat = FakeChat('{"name": "Fire Deal", "effects": [{"primitive_id": "deal"}]}')
+    card = generate_llamacpp_card(chat, payload, [{"name": "A", "effects": [{"primitive_id": "deal"}]}])
+    assert card["effects"] == [{"primitive_id": "burn", "weight": 1}]
+    assert card["name"] == "Cinder Warrant"
+
+
+# Verify screenshot-style generic names retry into authored names.
+def test_generate_llamacpp_card_retries_theme_and_mechanic_names() -> None:
+    payload = pack_payload("ice", "anime school", [], 3, 3)
+    chat = FakeChat(
+        [
+            '{"name": "Vulnerable Anime School", "effects": [{"primitive_id": "multi_hit"}]}',
+            '{"name": "Glass Edict", "effects": [{"primitive_id": "multi_hit"}]}',
+        ]
+    )
+    card = generate_llamacpp_card(chat, payload, [])
+    assert card["name"] == "Glass Edict"
+    assert len(chat.calls) == 2
+
+
+# Verify off-school imagery is rejected and retried.
+def test_generate_llamacpp_card_retries_off_school_imagery() -> None:
+    payload = pack_payload("fire", "wuxia", [], 2, 3)
+    chat = FakeChat(
+        [
+            '{"name": "Howling Glacier", "art_prompt": "frozen snow spell", "effects": [{"primitive_id": "deal"}]}',
+            '{"name": "Vow of Cinders", "art_prompt": "cinder oath spell", "effects": [{"primitive_id": "deal"}]}',
+        ]
+    )
+    card = generate_llamacpp_card(chat, payload, [])
+    assert card["name"] == "Vow of Cinders"
+    assert len(chat.calls) == 2
+
+
+# Verify school imagery validation catches Fire cards with Ice names.
+def test_school_flavor_mismatch() -> None:
+    assert school_flavor_mismatch("fire", {"name": "Howling Glacier"})
+    assert not school_flavor_mismatch("fire", {"name": "Vow of Cinders"})
+
+
 # Verify llama.cpp repair fills required schema fields.
 def test_repair_llamacpp_card_fills_missing_fields() -> None:
     payload = pack_payload("fire", "wuxia", [], 1, 3)
     raw = {"school": "fire", "effects": [{"primitive_id": "deal", "weight": 0}, {"primitive_id": "burn"}]}
     card = repair_llamacpp_card(raw, payload, [])
-    assert card["name"] == "Fire Deal Burn"
+    assert card["name"] == "Cinder Warrant"
     assert card["flavor"] == ""
     assert card["art_prompt"] == "wuxia fire card art"
     assert card["effects"] == [{"primitive_id": "deal", "weight": 1}, {"primitive_id": "burn", "weight": 1}]
 
 
+# Verify repair strips off-school imagery before costing.
+def test_repair_llamacpp_card_replaces_off_school_name() -> None:
+    payload = pack_payload("fire", "wuxia", [], 1, 3)
+    raw = {"name": "Howling Glacier", "art_prompt": "frozen snow spell", "effects": [{"primitive_id": "deal"}]}
+    card = repair_llamacpp_card(raw, payload, [])
+    assert card["name"] == "Cinder Warrant"
+    assert "frozen" not in card["art_prompt"]
+
+
+# Verify llama.cpp repair does not allow duplicate names inside one pack.
+def test_repair_llamacpp_card_uniquifies_duplicate_name() -> None:
+    payload = pack_payload("fire", "wuxia", [], 1, 3)
+    raw = {"name": "Firepress", "effects": [{"primitive_id": "deal"}]}
+    card = repair_llamacpp_card(raw, payload, [{"name": "Firepress"}, {"name": "Firepress 2"}])
+    assert card["name"] == "Firepress 3"
+
+
+# Verify generated name uniquing increments only when needed.
+def test_unique_card_name() -> None:
+    assert unique_card_name("A", []) == "A"
+    assert unique_card_name("A", [{"name": "A"}]) == "A 2"
+
+
 # Verify llama.cpp repair drops invalid primitives.
 def test_repair_llamacpp_card_drops_invalid_primitives() -> None:
     payload = pack_payload("ice", "wuxia", [], 1, 3)
@@ -525,7 +648,7 @@ def test_normalize_card_response_unwraps_shape() -> None:
 def test_parse_llamacpp_card_text_falls_back() -> None:
     payload = pack_payload("earth", "wuxia", [], 1, 3)
     card = parse_llamacpp_card_text('{"name" "Broken"}', payload, [])
-    assert card["name"] == "Earth Deal"
+    assert card["name"] == "Stone Covenant"
     assert card["effects"] == [{"primitive_id": "deal", "weight": 1}]
 
 
@@ -539,3 +662,21 @@ def test_codex_client_reports_failure(monkeypatch: pytest.MonkeyPatch, tmp_path:
     client = CodexCardClient(command=("codex", "exec", "-"), cwd=str(tmp_path))
     with pytest.raises(RuntimeError, match="blocked"):
         client.create_pack(pack_payload("fire", "wuxia", [], 1, 1))
+
+
+# Verify quick mode accepts the first card without a corrective retry.
+def test_generate_llamacpp_card_quick_skips_retry() -> None:
+    payload = pack_payload("fire", "wuxia", [], 2, 3)
+    payload["quick"] = True
+    chat = FakeChat('{"name": "Fire Deal", "effects": [{"primitive_id": "deal"}]}')
+    card = generate_llamacpp_card(chat, payload, [])
+    assert card["name"] == "Cinder Warrant"
+    assert len(chat.calls) == 1
+
+
+# Verify generate_pack threads the quick flag into the client payload.
+def test_generate_pack_threads_quick_flag() -> None:
+    card = {"name": "A", "flavor": "", "art_prompt": "", "effects": [{"primitive_id": "deal"}]}
+    client = FakePackClient({"cards": [card, dict(card, name="B"), dict(card, name="C")]})
+    generate_pack(client, "fire", "wuxia", [], 1, quick=True)
+    assert client.payload["quick"] is True

tests/test_local_llm.py

@@ -122,6 +122,7 @@ def test_chat_payload() -> None:
     assert payload["temperature"] == 0.5
     assert "max_tokens" not in payload
     assert chat_payload("local", "sys", "user", 0.5, 44)["max_tokens"] == 44
+    assert chat_payload("local", "sys", "user", 0.5, enable_thinking=False)["chat_template_kwargs"] == {"enable_thinking": False}
 
 
 # Verify completion payload shape matches OpenAI-compatible endpoints.
@@ -180,6 +181,7 @@ def test_local_chat_client(monkeypatch: Any) -> None:
     payload = json.loads(calls[0][0].data.decode("utf-8"))
     assert payload["model"] == "local"
     assert payload["max_tokens"] == 256
+    assert "chat_template_kwargs" not in payload
 
 
 # Verify local JSON chat client posts JSON mode payloads.

tests/test_ui.py

@@ -1,18 +1,29 @@
+import threading
+import time
+
+import forge
 from ui import (
     CARD_PANEL_COUNT,
     board_html,
+    boss_thought_lines,
+    card_html,
     choose_draft_card,
+    collect_ready_pack,
     choose_draft_card_steps,
     draft_screen_html,
     enemy_school_for,
     fallback_pack,
+    finish_opening_draft,
     log_html,
     mana_html,
     new_run,
+    new_run_shell,
     pass_turn,
     pass_turn_steps,
     pending_tokens_html,
     play_hand_card,
+    queue_next_pack,
+    refresh_art,
 )
 
 
@@ -38,6 +49,14 @@ def test_fallback_pack() -> None:
     assert any("banked shield charge" in card.rules_text() for card in pack)
 
 
+# Verify fallback Fire packs vary instead of repeating the same visible names.
+def test_fire_fallback_pack_rotates_names() -> None:
+    first = fallback_pack("fire", "dark fantasy", 2)
+    second = fallback_pack("fire", "dark fantasy", 3, current_deck=first)
+    assert {card.name for card in first}.isdisjoint({card.name for card in second})
+    assert all("card" not in card.art_prompt.lower() for card in first + second)
+
+
 # Verify a new run starts in draft state with three clickable cards.
 def test_new_run_starts_draft() -> None:
     state = new_run("Ada", "anime", "ice", seed=1)
@@ -50,6 +69,76 @@ def test_new_run_starts_draft() -> None:
     assert "Deck 6/15" in html
 
 
+# Verify a new run shell shows loading instead of unfinished starter cards.
+def test_new_run_shell_shows_loading() -> None:
+    state = new_run_shell("Ada", "anime", "ice", seed=1)
+    html = draft_screen_html(state)
+    assert "loading-bar" in html
+    assert "Starter Deck" not in html
+    assert "starter-card" not in html
+    assert "draft-btn" not in html
+
+
+# Verify queued first packs render a loading bar instead of blocking.
+def test_queue_next_pack_shows_loading() -> None:
+    forge.reset()
+    client = ForgePackClient()
+    state = queue_next_pack(new_run_shell("Ada", "anime", "ice", seed=1), client)
+    html = draft_screen_html(state)
+    assert "loading-bar" in html
+    assert "Forging your first draft pack" in html
+    assert "draft-btn" not in html
+
+
+# Verify a ready background pack replaces the loading state.
+def test_collect_ready_pack_installs_pack() -> None:
+    forge.reset()
+    client = ForgePackClient()
+    state = queue_next_pack(new_run_shell("Ada", "anime", "ice", seed=1), client)
+    forge.drain()
+    state = collect_ready_pack(state, client)
+    assert "loading-bar" in draft_screen_html(state)
+    forge.drain()
+    state = collect_ready_pack(state, client)
+    html = draft_screen_html(state)
+    assert "loading-bar" not in html
+    assert html.count("draft-card") == CARD_PANEL_COUNT
+    assert "draft-btn-0" in html
+
+
+# Verify draft packs reveal text before queued art settles.
+def test_collect_ready_pack_reveals_before_art() -> None:
+    forge.reset()
+    client = ForgePackClient()
+    art_client = GatedArtClient()
+    state = queue_next_pack(new_run_shell("Ada", "anime", "ice", seed=1), client, art_client)
+    forge.drain()
+    state = collect_ready_pack(state, client, art_client)
+    assert "loading-bar" in draft_screen_html(state)
+    for _ in range(20):
+        time.sleep(0.01)
+        state = collect_ready_pack(state, client, art_client)
+        if state.current_pack:
+            break
+    html = draft_screen_html(state)
+    assert "draft-btn-0" in html
+    assert "pending-art" in html
+    assert all(card.art_uri == "" for card in state.current_pack)
+    art_client.released.set()
+    forge.drain()
+    state = refresh_art(state)
+    assert all(card.art_uri for card in state.current_pack)
+
+
+# Verify opening draft completion replaces the starter view with clickable picks.
+def test_finish_opening_draft_deals_first_pack() -> None:
+    state = finish_opening_draft(new_run_shell("Ada", "anime", "ice", seed=1))
+    html = draft_screen_html(state)
+    assert "Starter Deck" not in html
+    assert html.count("draft-card") == CARD_PANEL_COUNT
+    assert "draft-btn-0" in html
+
+
 # Verify choosing nine draft cards starts combat.
 def test_choose_draft_card_starts_battle() -> None:
     state = battle_state()
@@ -180,12 +269,39 @@ def test_boss_turn_shows_thinking() -> None:
         thinking = [step for step in steps if step.boss_thinking]
         if thinking:
             assert "boss-thinking" in board_html(thinking[0])
-            assert "Boss is scheming" in board_html(thinking[0])
+            assert "The boss" in board_html(thinking[0])
+            assert "Boss is scheming" not in board_html(thinking[0])
             return
         state = steps[-1]
     raise AssertionError("boss never took a visible thinking step")
 
 
+# Verify boss thinking exposes public tactical trace beats.
+def test_boss_thought_lines_show_public_trace() -> None:
+    from game import PendingEffect
+
+    state = battle_state(seed=4)
+    state.duel.enemy.hp = 7
+    state.duel.enemy.energy = 5
+    state.duel.pending.append(PendingEffect("bomb", state.duel.player.name, state.duel.enemy.name, 5, delay=1))
+    thoughts = boss_thought_lines(state)
+    assert thoughts[0] == "The boss realizes a 5-damage bomb lands in 2 turns."
+    assert "looks at its health: 7 HP" in thoughts[1]
+    assert "without revealing them" in thoughts[2]
+    assert all(card.name not in thoughts[2] for card in state.duel.enemy.hand)
+
+
+# Verify boss trace frames use short delays to keep turns responsive.
+def test_frame_delay_shortens_boss_trace() -> None:
+    from dataclasses import replace
+
+    from app import frame_delay
+
+    state = battle_state(seed=4)
+    assert frame_delay(replace(state, boss_thinking=True)) == 0.35
+    assert frame_delay(state) == 0.45
+
+
 # Verify boss cards stream in one step at a time, newest marked fresh.
 def test_boss_plays_stream_stepwise() -> None:
     state = battle_state(seed=4)
@@ -316,3 +432,94 @@ def test_log_html_newest_first() -> None:
     newest = state.log[-1]
     assert html.index(newest[:20]) < html.index(state.log[0][:10])
     assert log_html(None) == ""
+
+
+class ForgePackClient:
+    # Thread-safe fake pack client with distinct card names per call.
+    def __init__(self) -> None:
+        self.lock = threading.Lock()
+        self.calls = 0
+
+    # Return one synthetic pack, numbering cards across calls.
+    def create_pack(self, payload):
+        with self.lock:
+            self.calls += 1
+            base = self.calls * 10
+        card = lambda i: {"name": f"Forged {base + i}", "flavor": "x", "art_prompt": "y", "effects": [{"primitive_id": "deal", "weight": 1}]}
+        return {"cards": [card(i) for i in range(payload["pack_size"])]}
+
+
+class FakeArtClient:
+    # Return a stable URI for each generated art prompt.
+    def create_art(self, prompt: str) -> str:
+        return f"uri:{prompt}"
+
+
+class GatedArtClient:
+    # Wait until the test releases the image job.
+    def __init__(self) -> None:
+        self.released = threading.Event()
+
+    # Return a stable URI after the gate opens.
+    def create_art(self, prompt: str) -> str:
+        self.released.wait(1)
+        return f"uri:{prompt}"
+
+
+# Verify a new run pre-forges candidate packs and the boss deck in the background.
+def test_new_run_warms_forge() -> None:
+    forge.reset()
+    client = ForgePackClient()
+    state = new_run("Ada", "anime", "ice", client, seed=3)
+    forge.drain()
+    assert client.calls == 13  # pack 1, three speculative next packs, nine boss packs
+    picked = choose_draft_card(state, 0, client)
+    assert all(card.name.startswith("Forged") for card in picked.current_pack)
+
+
+# Verify battle start consumes the pre-forged boss deck.
+def test_battle_uses_forged_boss_deck() -> None:
+    forge.reset()
+    client = ForgePackClient()
+    state = new_run("Ada", "anime", "ice", client, seed=3)
+    for _ in range(9):
+        state = choose_draft_card(state, 0, client)
+    assert state.duel is not None
+    assert any(card.name.startswith("Forged") for card in state.enemy_deck)
+
+
+# Verify generated card art renders into the card face.
+def test_card_html_renders_generated_art() -> None:
+    card = fallback_pack("fire", "dark fantasy", 2)[0]
+    html = card_html(card.__class__(**{**card.__dict__, "art_uri": "data:image/png;base64,abc"}))
+    assert "card-art generated" in html
+    assert "data:image/png;base64,abc" in html
+
+
+# Verify draft packs can be illustrated through the art client.
+def test_new_run_illustrates_draft_cards() -> None:
+    forge.reset()
+    client = ForgePackClient()
+    art_client = GatedArtClient()
+    state = new_run("Ada", "anime", "ice", client, seed=3, art_client=art_client)
+    assert all(card.art_uri == "" for card in state.current_pack)
+    art_client.released.set()
+    forge.drain()
+    state = refresh_art(state)
+    assert all(card.art_uri.startswith("uri:") for card in state.current_pack)
+
+
+# Verify battle start queues art for visible combat cards.
+def test_battle_warms_visible_card_art() -> None:
+    forge.reset()
+    client = ForgePackClient()
+    art_client = FakeArtClient()
+    state = new_run("Ada", "anime", "ice", client, seed=3, art_client=art_client)
+    for _ in range(9):
+        state = choose_draft_card(state, 0, client, art_client)
+    forge.drain()
+    state = refresh_art(state)
+    duel = state.duel
+    assert all(card.art_uri for card in duel.player.hand)
+    assert all(card.art_uri for card in duel.enemy.hand)
+    assert any(not card.art_uri for card in duel.player.deck)

ui.py

@@ -3,6 +3,8 @@ from dataclasses import dataclass, replace
 from random import Random
 from typing import Sequence
 
+import forge
+from art import ArtClient, illustrate_card
 from boss import boss_chooser
 from budget import Card, CardSpec, EffectPlan, cost_card
 from clients import boss_client_from_env
@@ -35,11 +37,14 @@ class RunState:
     turn_position: int
     log: tuple[str, ...]
     rng: Random
+    enemy_seed: int = 0
     showcase: tuple[tuple[str, Card], ...] = ()
     hp_flash: tuple[int, int] = (0, 0)
     round_flash: int = 0
     boss_thinking: bool = False
+    boss_thought: str = ""
     pack_fading: int = -1
+    loading: str = ""
 
 
 Steps = Iterator[RunState]
@@ -50,8 +55,13 @@ def enemy_school_for(school: School) -> School:
     return {"fire": "earth", "earth": "ice", "ice": "fire"}[school]
 
 
-# Start a new run and generate the first draft pack.
-def new_run(player_name: str, world: str, school: School, client: CardPackClient | None = None, seed: int = 7) -> RunState:
+# Start a new run shell with the starter deck visible immediately.
+def new_run_shell(
+    player_name: str,
+    world: str,
+    school: School,
+    seed: int = 7,
+) -> RunState:
     rng = Random(seed)
     player_deck = backbone_deck(school, world or THEME)
     enemy_school = enemy_school_for(school)
@@ -73,54 +83,242 @@ def new_run(player_name: str, world: str, school: School, client: CardPackClient
         turn_position=0,
         log=(f"{player_name or 'You'} enters {world or THEME}.",),
         rng=rng,
+        enemy_seed=rng.getrandbits(32),
     )
-    return deal_next_pack(state, client)
+    return state
 
 
-# Choose a draft card, yielding paced battle states once drafting completes.
-def choose_draft_card_steps(state: RunState, index: int, client: CardPackClient | None = None) -> Steps:
-    if index < 0 or index >= len(state.current_pack):
-        yield add_log(state, "That draft card is not available.")
-        return
+# Start a new run, generate the first draft pack, and warm the background forge.
+def new_run(
+    player_name: str,
+    world: str,
+    school: School,
+    client: CardPackClient | None = None,
+    seed: int = 7,
+    art_client: ArtClient | None = None,
+) -> RunState:
+    state = new_run_shell(player_name, world, school, seed)
+    warm_enemy_deck(state, client, art_client)
+    state = deal_next_pack(state, client, art_client)
+    prefetch_next_packs(state, client, art_client)
+    return state
+
+
+# Finish the first generated draft pack for a visible starter-deck shell.
+def finish_opening_draft(
+    state: RunState,
+    client: CardPackClient | None = None,
+    art_client: ArtClient | None = None,
+) -> RunState:
+    warm_enemy_deck(state, client, art_client)
+    state = deal_next_pack(state, client, art_client)
+    prefetch_next_packs(state, client, art_client)
+    return state
+
+
+# Queue the next draft pack and render a loading state instead of blocking.
+def queue_next_pack(
+    state: RunState,
+    client: CardPackClient | None = None,
+    art_client: ArtClient | None = None,
+) -> RunState:
+    warm_enemy_deck(state, client, art_client)
+    if state.draft_step >= len(state.draft_order):
+        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))
+
+
+# Attach a queued draft pack once its background job finishes.
+def collect_ready_pack(
+    state: RunState,
+    client: CardPackClient | None = None,
+    art_client: ArtClient | None = None,
+) -> RunState:
+    if state.duel is not None or state.current_pack or state.draft_step >= len(state.draft_order):
+        return state
+    cost = SYNERGY_COSTS[state.draft_order[state.draft_step]]
+    pack = forge.take_ready(pack_key(state))
+    if pack is None:
+        forge.submit(pack_key(state), pack_maker(client, art_client, state, cost))
+        return state
+    warm_card_art(art_client, pack)
+    pack = collect_ready_cards(pack)
+    preview_state = replace(state, current_pack=pack, loading="")
+    if state.draft_step == 0 and client is not None:
+        prefetch_next_packs(preview_state, client, art_client)
+        if not next_packs_ready(preview_state):
+            return state
+    state = preview_state
+    prefetch_next_packs(state, client, art_client)
+    return state
+
+
+# Return whether all one-pick-ahead packs are already forged.
+def next_packs_ready(state: RunState) -> bool:
+    for index in range(len(state.current_pack)):
+        nxt = apply_pick(state, index)
+        if nxt.draft_step >= len(nxt.draft_order):
+            continue
+        if forge.take_ready(pack_key(nxt)) is None:
+            return False
+    return True
+
+
+# Return copy for the visible draft loading state.
+def loading_message(state: RunState) -> str:
+    if state.draft_step == 0:
+        return "Forging your first draft pack"
+    return "Forging the next draft pack"
+
+
+# Apply one draft pick to the run state.
+def apply_pick(state: RunState, index: int) -> RunState:
     selected = state.current_pack[index]
     cost_index = state.draft_order[state.draft_step]
     anchors = state.draft_anchors + ((selected,) if cost_index in state.anchor_indexes else ())
-    state = replace(
+    return replace(
         state,
         player_deck=state.player_deck + (selected,),
         draft_anchors=anchors,
         draft_step=state.draft_step + 1,
         log=state.log + (f"Drafted {selected.name}.",),
     )
+
+
+# Choose a draft card, yielding paced battle states once drafting completes.
+def choose_draft_card_steps(
+    state: RunState,
+    index: int,
+    client: CardPackClient | None = None,
+    art_client: ArtClient | None = None,
+) -> Steps:
+    state = refresh_art(state)
+    if index < 0 or index >= len(state.current_pack):
+        yield add_log(state, "That draft card is not available.")
+        return
+    state = apply_pick(state, index)
+    yield replace(state, pack_fading=index)
+    if state.draft_step >= len(state.draft_order):
+        yield from start_battle_steps(state, client, art_client)
+        return
+    state = deal_next_pack(state, client, art_client)
+    prefetch_next_packs(state, client, art_client)
+    yield replace(state, pack_fading=-1)
+
+
+# Choose a draft card and queue the next pack without blocking UI rendering.
+def choose_draft_card_loading_steps(
+    state: RunState,
+    index: int,
+    client: CardPackClient | None = None,
+    art_client: ArtClient | None = None,
+) -> Steps:
+    state = refresh_art(state)
+    if index < 0 or index >= len(state.current_pack):
+        yield add_log(state, "That draft card is not available.")
+        return
+    state = apply_pick(state, index)
     yield replace(state, pack_fading=index)
     if state.draft_step >= len(state.draft_order):
-        yield from start_battle_steps(state, client)
+        yield from start_battle_steps(state, client, art_client)
         return
-    yield replace(deal_next_pack(state, client), pack_fading=-1)
+    yield queue_next_pack(replace(state, pack_fading=-1), client, art_client)
 
 
 # Choose a draft card and advance to the next pack or battle.
-def choose_draft_card(state: RunState, index: int, client: CardPackClient | None = None) -> RunState:
-    return last_state(choose_draft_card_steps(state, index, client))
+def choose_draft_card(
+    state: RunState,
+    index: int,
+    client: CardPackClient | None = None,
+    art_client: ArtClient | None = None,
+) -> RunState:
+    return last_state(choose_draft_card_steps(state, index, client, art_client))
 
 
-# Generate the next draft pack.
-def deal_next_pack(state: RunState, client: CardPackClient | None = None) -> RunState:
-    cost_index = state.draft_order[state.draft_step]
-    cost = SYNERGY_COSTS[cost_index]
-    pack = make_pack(client, state.school, state.world, state.player_deck, cost, state.draft_anchors)
-    return replace(state, current_pack=pack)
+# Deal the next draft pack, preferring a forge-prefetched one.
+def deal_next_pack(
+    state: RunState,
+    client: CardPackClient | None = None,
+    art_client: ArtClient | None = None,
+) -> RunState:
+    cost = SYNERGY_COSTS[state.draft_order[state.draft_step]]
+    maker = pack_maker(client, art_client, state, cost)
+    pack = forge.take(pack_key(state), maker) if client is not None else maker()
+    warm_card_art(art_client, pack)
+    return replace(state, current_pack=collect_ready_cards(pack))
+
+
+# Return a deck-content signature for forge keys.
+def deck_sig(cards: Sequence[Card]) -> tuple[str, ...]:
+    return tuple(f"{card.cost} {card.name}" for card in cards)
+
+
+# Return the forge key for the next pack of one draft state.
+def pack_key(state: RunState) -> tuple:
+    return ("pack", state.enemy_seed, state.draft_step, deck_sig(state.player_deck), deck_sig(state.draft_anchors))
+
+
+# Build a pack generator bound to one draft state.
+def pack_maker(
+    client: CardPackClient | None,
+    art_client: ArtClient | None,
+    state: RunState,
+    cost: int,
+) -> Callable[[], tuple[Card, ...]]:
+    return lambda: make_pack(client, None, state.school, state.world, state.player_deck, cost, state.draft_anchors)
+
+
+# Pre-generate every candidate next pack while the player reads the current one.
+def prefetch_next_packs(state: RunState, client: CardPackClient | None, art_client: ArtClient | None) -> None:
+    if client is None or state.draft_step >= len(state.draft_order):
+        return
+    for index in range(len(state.current_pack)):
+        nxt = apply_pick(state, index)
+        if nxt.draft_step >= len(nxt.draft_order):
+            continue
+        cost = SYNERGY_COSTS[nxt.draft_order[nxt.draft_step]]
+        forge.submit(pack_key(nxt), pack_maker(client, art_client, nxt, cost))
+
+
+# Return the forge key for the boss deck of one run.
+def enemy_deck_key(state: RunState) -> tuple:
+    return ("enemy", state.enemy_school, state.world, state.enemy_seed)
+
+
+# Build a boss-deck generator with its own deterministic rng.
+def enemy_deck_maker(
+    client: CardPackClient | None,
+    art_client: ArtClient | None,
+    state: RunState,
+) -> Callable[[], tuple[Card, ...]]:
+    return lambda: draft_enemy_deck_for_ui(client, art_client, state.enemy_school, state.world, Random(state.enemy_seed))
+
+
+# Start forging the boss deck on the slow lane during the draft.
+def warm_enemy_deck(state: RunState, client: CardPackClient | None, art_client: ArtClient | None) -> None:
+    if client is not None:
+        forge.submit(enemy_deck_key(state), enemy_deck_maker(client, art_client, state), lane="slow")
 
 
 # Start combat after drafting, yielding paced states for the opening round.
-def start_battle_steps(state: RunState, client: CardPackClient | None = None) -> Steps:
-    enemy_deck = draft_enemy_deck_for_ui(client, state.enemy_school, state.world, state.rng)
+def start_battle_steps(
+    state: RunState,
+    client: CardPackClient | None = None,
+    art_client: ArtClient | None = None,
+) -> Steps:
+    state = refresh_art(state)
+    maker = enemy_deck_maker(client, art_client, state)
+    enemy_deck = forge.take(enemy_deck_key(state), maker) if client is not None else maker()
     duel = DuelState(
         create_player(state.player_name, shuffled_deck(state.player_deck, state.rng)),
         create_player("Boss", shuffled_deck(enemy_deck, state.rng)),
     )
     draw_cards(duel.player, OPENING_HAND_SIZE)
     draw_cards(duel.enemy, OPENING_HAND_SIZE)
+    warm_card_art(art_client, duel.player.hand)
+    warm_card_art(art_client, duel.enemy.hand)
     state = replace(
         state,
         enemy_deck=enemy_deck,
@@ -128,16 +326,33 @@ def start_battle_steps(state: RunState, client: CardPackClient | None = None) ->
         duel=duel,
         log=state.log + ("The boss takes the far side of the table.",),
     )
-    yield from paced_action(state, advance_to_player_steps)
+    for step in paced_action(state, advance_to_player_steps):
+        warm_battle_art(art_client, step)
+        yield step
+
+
+# Queue art for currently visible combat cards.
+def warm_battle_art(art_client: ArtClient | None, state: RunState) -> None:
+    if state.duel is None:
+        return
+    warm_card_art(art_client, state.duel.player.hand)
+    warm_card_art(art_client, state.duel.enemy.hand)
+    warm_card_art(art_client, tuple(card for _, card in state.showcase))
 
 
 # Draft a boss deck for the UI.
-def draft_enemy_deck_for_ui(client: CardPackClient | None, school: School, world: str, rng: Random) -> tuple[Card, ...]:
+def draft_enemy_deck_for_ui(
+    client: CardPackClient | None,
+    art_client: ArtClient | None,
+    school: School,
+    world: str,
+    rng: Random,
+) -> tuple[Card, ...]:
     deck = list(backbone_deck(school, world))
     anchors: list[Card] = []
     anchor_indexes = draft_anchor_indexes(len(SYNERGY_COSTS), rng)
     for cost_index in draft_order(len(SYNERGY_COSTS), anchor_indexes):
-        pack = make_pack(client, school, world, tuple(deck), SYNERGY_COSTS[cost_index], tuple(anchors))
+        pack = make_pack(client, None, school, world, tuple(deck), SYNERGY_COSTS[cost_index], tuple(anchors), quick=True)
         selected = pack[best_draft_index(tuple(deck), pack)]
         deck.append(selected)
         if cost_index in anchor_indexes:
@@ -148,44 +363,152 @@ def draft_enemy_deck_for_ui(client: CardPackClient | None, school: School, world
 # Generate a model pack or deterministic fallback.
 def make_pack(
     client: CardPackClient | None,
+    art_client: ArtClient | None,
     school: School,
     world: str,
     current_deck: Sequence[Card],
     cost: int,
     anchors: Sequence[Card] = (),
+    quick: bool = False,
 ) -> tuple[Card, ...]:
     if client is not None:
         try:
-            return generate_pack(client, school, world, current_deck, cost, draft_anchors=anchors)
+            pack = generate_pack(client, school, world, current_deck, cost, draft_anchors=anchors, quick=quick)
+            return collect_ready_cards(pack)
         except Exception:
             pass
-    return fallback_pack(school, world, cost, anchors)
+    pack = fallback_pack(school, world, cost, anchors, current_deck)
+    return collect_ready_cards(pack)
+
+
+# Return the stable background-art key for one card face.
+def card_art_key(card: Card) -> tuple:
+    return ("art", card.school, card.theme, card.cost, card.name, card.rules_text(), card.flavor, card.art_prompt)
+
+
+# Start card illustration jobs on the dedicated art lane so images never queue
+# behind the boss-deck draft (slow lane) or the player's packs (fast lane).
+def warm_card_art(art_client: ArtClient | None, cards: Sequence[Card]) -> None:
+    if art_client is None:
+        return
+    for card in cards:
+        if not card.art_uri:
+            forge.submit(card_art_key(card), lambda card=card: illustrate_card(art_client, card), lane="art")
+
+
+# Attach a finished generated image to one card if the forge has it.
+def collect_ready_card(card: Card) -> Card:
+    if card.art_uri:
+        return card
+    illustrated = forge.take_ready(card_art_key(card), card)
+    if isinstance(illustrated, Card) and illustrated.art_uri:
+        return illustrated
+    return card
+
+
+# Attach any finished generated images to a card sequence.
+def collect_ready_cards(cards: Sequence[Card]) -> tuple[Card, ...]:
+    return tuple(collect_ready_card(card) for card in cards)
+
+
+# Return cards plus whether all queued art jobs have settled.
+def collect_pack_art_status(cards: Sequence[Card], art_client: ArtClient | None) -> tuple[tuple[Card, ...], bool]:
+    if art_client is None:
+        return collect_ready_cards(cards), True
+    collected = tuple(collect_ready_art_status(card) for card in cards)
+    return tuple(card for card, _ in collected), all(ready for _, ready in collected)
+
+
+# Return one card plus whether its art job has settled.
+def collect_ready_art_status(card: Card) -> tuple[Card, bool]:
+    if card.art_uri:
+        return card, True
+    illustrated = forge.take_ready(card_art_key(card))
+    if illustrated is None:
+        return card, False
+    if isinstance(illustrated, Card):
+        return illustrated, True
+    return card, True
+
+
+# Refresh generated art across the visible run state.
+def refresh_art(state: RunState | None) -> RunState | None:
+    if state is None:
+        return None
+    return replace(
+        state,
+        player_deck=collect_ready_cards(state.player_deck),
+        enemy_deck=collect_ready_cards(state.enemy_deck),
+        current_pack=collect_ready_cards(state.current_pack),
+        duel=refresh_duel_art(state.duel),
+    )
+
+
+# Attach finished generated images inside an active duel.
+def refresh_duel_art(duel: DuelState | None) -> DuelState | None:
+    if duel is None:
+        return None
+    return replace(duel, player=refresh_player_art(duel.player), enemy=refresh_player_art(duel.enemy))
+
+
+# Attach finished generated images inside one player zone.
+def refresh_player_art(player: PlayerState) -> PlayerState:
+    return replace(
+        player,
+        deck=list(collect_ready_cards(player.deck)),
+        hand=list(collect_ready_cards(player.hand)),
+        discard=list(collect_ready_cards(player.discard)),
+    )
 
 
 # Return a deterministic draft pack when no model is configured.
-def fallback_pack(school: School, world: str, cost: int, anchors: Sequence[Card] = ()) -> tuple[Card, ...]:
-    plans = fallback_plans(school, anchors)
+def fallback_pack(
+    school: School,
+    world: str,
+    cost: int,
+    anchors: Sequence[Card] = (),
+    current_deck: Sequence[Card] = (),
+) -> tuple[Card, ...]:
+    plans = fallback_plans(school, anchors, cost, current_deck)
     return tuple(cost_card(CardSpec(name, cost, school, world, effects, flavor, art)) for name, effects, flavor, art in plans)
 
 
 # Return fallback effect plans for a school.
-def fallback_plans(school: School, anchors: Sequence[Card]) -> tuple[tuple[str, tuple[EffectPlan, ...], str, str], ...]:
+def fallback_plans(
+    school: School,
+    anchors: Sequence[Card],
+    cost: int = 1,
+    current_deck: Sequence[Card] = (),
+) -> tuple[tuple[str, tuple[EffectPlan, ...], str, str], ...]:
     if school == "fire":
-        return (
-            ("Cinder Rush", (EffectPlan("deal"), EffectPlan("burn")), "Heat hits first, then keeps biting.", "burning playing card on a wooden table"),
-            ("Fuse Prayer", (EffectPlan("bomb"),), "A delayed blast tucked under the enemy's next breath.", "black powder sigil glowing under ash"),
-            ("Kindling Draw", (EffectPlan("draw"), EffectPlan("deal")), "The next spark finds your hand.", "embers curling into paper cards"),
+        variants = (
+            (
+                ("Cinder Rush", (EffectPlan("deal"), EffectPlan("burn")), "Heat hits first, then keeps biting.", "a rushing ribbon of cinders across black stone"),
+                ("Fuse Prayer", (EffectPlan("bomb"),), "A delayed blast tucked under the enemy's next breath.", "black powder sigil glowing under ash"),
+                ("Kindling Draw", (EffectPlan("draw"), EffectPlan("deal")), "The next spark finds your hand.", "embers rising into a bright spiral"),
+            ),
+            (
+                ("Ember Warrant", (EffectPlan("deal"),), "The sentence arrives before the smoke.", "a red-hot seal stamped into dark basalt"),
+                ("Blackpowder Hymn", (EffectPlan("bomb"), EffectPlan("burn")), "Every note waits for the fuse.", "sparks crawling through a ritual fuse circle"),
+                ("Coalglass Vow", (EffectPlan("draw"), EffectPlan("burn")), "The oath glows brighter when broken.", "molten glass reflecting a small flame"),
+            ),
+            (
+                ("Ashen Oath", (EffectPlan("burn"), EffectPlan("scaling")), "A promise written in soot remembers every spark.", "ash lifting from a cracked ember sigil"),
+                ("Red Sigil", (EffectPlan("deal"), EffectPlan("draw")), "One mark, one opening, one breath of heat.", "a crimson rune flaring in smoke"),
+                ("Charcoal Saint", (EffectPlan("block"), EffectPlan("burn")), "The saint shields with one hand and burns with the other.", "a soot-black statue lit from within"),
+            ),
         )
+        return variants[fallback_variant_index(cost, current_deck, len(variants))]
     if school == "ice":
         return (
-            ("Glass Tempo", (EffectPlan("initiative"), EffectPlan("vulnerable")), "The table freezes one heartbeat ahead.", "frosted hourglass over cards"),
-            ("Needle Flurry", (EffectPlan("multi_hit"),), "Small cuts find the opening.", "ice needles striking a portrait frame"),
+            ("Glass Tempo", (EffectPlan("initiative"), EffectPlan("vulnerable")), "The air freezes one heartbeat ahead.", "frosted hourglass above a frozen floor"),
+            ("Needle Flurry", (EffectPlan("multi_hit"),), "Small cuts find the opening.", "ice needles crossing a moonlit hall"),
             ("Crack in Winter", (EffectPlan("vulnerable"), EffectPlan("conditional")), "A weakness appears where the frost thins.", "blue crack in a frozen shield"),
         )
     if any(effect.primitive_id == "scaling" for card in anchors for effect in card.effects):
         return (
             ("Stone Intake", (EffectPlan("block"), EffectPlan("scaling")), "The shield drinks the blow and answers later.", "stone shield lit with stored gold"),
-            ("Table Ward", (EffectPlan("block"), EffectPlan("ward")), "A quiet wall between you and ruin.", "earthen ward on an old desk"),
+            ("Table Ward", (EffectPlan("block"), EffectPlan("ward")), "A quiet wall between you and ruin.", "earthen ward carved into dark stone"),
             ("Buried Leverage", (EffectPlan("draw"), EffectPlan("block")), "Patience becomes pressure.", "roots lifting cards from soil"),
         )
     return (
@@ -195,6 +518,11 @@ def fallback_plans(school: School, anchors: Sequence[Card]) -> tuple[tuple[str,
     )
 
 
+# Return the rotating fallback pack index.
+def fallback_variant_index(cost: int, current_deck: Sequence[Card], count: int) -> int:
+    return (cost + len(current_deck)) % count
+
+
 # Play one hand card, yielding paced states for the boss response.
 def play_hand_card_steps(state: RunState, index: int) -> Steps:
     if state.duel is None or index < 0 or index >= len(state.duel.player.hand):
@@ -230,7 +558,7 @@ def paced_action(state: RunState, steps_fn: Callable[..., Steps], *args: object)
     assert state.duel is not None
     duel = state.duel
     player_hp, enemy_hp, round_seen = duel.player.hp, duel.enemy.hp, duel.round_number
-    fresh = replace(state, showcase=(), hp_flash=(0, 0), round_flash=0, boss_thinking=False)
+    fresh = replace(state, showcase=(), hp_flash=(0, 0), round_flash=0, boss_thinking=False, boss_thought="")
     for step in steps_fn(fresh, *args):
         assert step.duel is not None
         flash = (max(0, player_hp - step.duel.player.hp), max(0, enemy_hp - step.duel.enemy.hp))
@@ -317,7 +645,8 @@ def boss_turn_steps(state: RunState) -> Steps:
     chooser = ui_boss_chooser()
     played_any = False
     while playable_indexes(state.duel.enemy):
-        yield replace(state, boss_thinking=True)
+        for thought in boss_thought_lines(state):
+            yield replace(state, boss_thinking=True, boss_thought=thought)
         choice = chooser(state.duel, state.duel.enemy)
         if choice is None:
             state.duel.enemy.energy = 0
@@ -337,6 +666,50 @@ def boss_turn_steps(state: RunState) -> Steps:
     return state
 
 
+# Return short visible boss reasoning beats from public board state.
+def boss_thought_lines(state: RunState) -> tuple[str, ...]:
+    assert state.duel is not None
+    return (
+        boss_pending_thought(state.duel),
+        boss_health_thought(state.duel.enemy),
+        boss_hand_thought(state.duel.enemy),
+    )
+
+
+# Return the boss thought about incoming delayed effects.
+def boss_pending_thought(duel: DuelState) -> str:
+    threats = [effect for effect in duel.pending if effect.target == duel.enemy.name]
+    bombs = [effect for effect in threats if effect.primitive_id == "bomb"]
+    burns = [effect for effect in threats if effect.primitive_id == "burn"]
+    if bombs:
+        soonest = min(effect.delay + 1 for effect in bombs)
+        total = sum(effect.amount for effect in bombs)
+        label = "turn" if soonest == 1 else "turns"
+        return f"The boss realizes a {total}-damage bomb lands in {soonest} {label}."
+    if burns:
+        total = sum(effect.amount for effect in burns)
+        return f"The boss notices {total} burn damage still ticking."
+    return "The boss scans the table for delayed threats."
+
+
+# Return the boss thought about its own health and defenses.
+def boss_health_thought(enemy: PlayerState) -> str:
+    defenses = enemy.block + enemy.ward
+    if enemy.hp <= 8:
+        return f"The boss looks at its health: {enemy.hp} HP, with {defenses} defense."
+    return f"The boss checks its health: {enemy.hp} HP, with {defenses} defense."
+
+
+# Return the boss thought about playable hand options.
+def boss_hand_thought(enemy: PlayerState) -> str:
+    playable = playable_indexes(enemy)
+    if not playable:
+        return "The boss considers its hand and finds no playable card."
+    count = len(playable)
+    label = "line" if count == 1 else "lines"
+    return f"The boss considers {count} playable {label} without revealing them."
+
+
 # Record one played card for the battlefield showcase.
 def show_play(state: RunState, owner: str, card: Card) -> RunState:
     return replace(state, showcase=state.showcase + ((owner, card),))
@@ -356,7 +729,7 @@ def add_log(state: RunState, line: str) -> RunState:
     return replace(state, log=(state.log + (line,))[-80:])
 
 
-# Return HTML for one card face with a blank art slot for future generation.
+# Return HTML for one card face.
 def card_html(card: Card | None, classes: str = "", style: str = "", onclick: str = "") -> str:
     if card is None:
         return "<div class='tabras-card empty'></div>"
@@ -364,17 +737,27 @@ def card_html(card: Card | None, classes: str = "", style: str = "", onclick: st
         f'<div class="tabras-card school-{card.school} {classes}" style="{style}" onclick="{onclick}">'
         f"<div class='card-cost'>{card.cost}</div>"
         f"<div class='card-name'>{escape_html(card.name)}</div>"
-        "<div class='card-art'></div>"
+        f"{card_art_html(card)}"
         f"<div class='card-rules'>{escape_html(card.rules_text())}</div>"
         f"<div class='card-flavor'>{escape_html(card.flavor)}</div>"
         "</div>"
     )
 
 
+# Return a card art panel, using generated art when present.
+def card_art_html(card: Card) -> str:
+    if not card.art_uri:
+        return f"<div class='card-art pending-art school-art-{card.school}'></div>"
+    return f'<div class="card-art generated" style="background-image:url(&quot;{escape_html(card.art_uri)}&quot;)"></div>'
+
+
 # Return HTML for the full draft screen.
 def draft_screen_html(state: RunState | None) -> str:
-    if state is None or state.duel is not None or not state.current_pack:
+    if state is None or state.duel is not None:
         return ""
+    if not state.current_pack:
+        loading = loading_html(state.loading or "Forging draft pack")
+        return f"<div class='draft-board loading-board'>{loading}{deck_strip_html(state)}</div>"
     if state.draft_step >= len(state.draft_order):
         banner = "<div class='draft-banner'><h2>Deck complete</h2><p>The boss shuffles its deck&hellip;</p></div>"
     else:
@@ -390,6 +773,22 @@ def draft_screen_html(state: RunState | None) -> str:
     return f"<div class='draft-board'>{banner}<div class='draft-pack'>{cards}</div>{deck_strip_html(state)}</div>"
 
 
+# Return loading HTML for asynchronous draft generation.
+def loading_html(message: str) -> str:
+    return (
+        "<div class='draft-loading'>"
+        f"<div class='loading-title'>{escape_html(message)}</div>"
+        "<div class='loading-bar'><span></span></div>"
+        "<div class='loading-subtitle'>Your first draft pack is being prepared.</div>"
+        "</div>"
+    )
+
+
+# Return one starter-deck card without draft click behavior.
+def starter_card_html(card: Card) -> str:
+    return card_html(card, "starter-card")
+
+
 # Return one draft card, fading the old pack out after a pick.
 def draft_card_html(state: RunState, index: int, card: Card) -> str:
     if state.pack_fading < 0:
@@ -431,7 +830,8 @@ def board_html(state: RunState | None) -> str:
 def enemy_zone_html(state: RunState) -> str:
     assert state.duel is not None
     enemy = state.duel.enemy
-    thinking = "<div class='boss-thinking'>Boss is scheming&hellip;</div>" if state.boss_thinking else ""
+    thought = state.boss_thought or "The boss studies the board."
+    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>"