Sync from dev: Qwen3-14B (single model) + FLUX.2-klein, generative scribe, 4-way parallel scribe/paint, lazy deck view, prompt logging, GUI + card-frame fixes

app.py

@@ -24,6 +24,7 @@ import base64
 import html
 import json
 import os
+import re
 import tempfile
 import threading
 import time
@@ -75,7 +76,7 @@ if os.environ.get("IMAGE_BACKEND", "").lower() == "local":
 
 WELCOME = ("Welcome, traveler. Every world has its hidden archetypes. "
            "Name one, and I shall draw out its fortune.")
-EXAMPLE_THEMES = ["Physics", "Birds", "Lord of the Rings Characters", "Breakfast Foods"]
+EXAMPLE_THEMES = ["physics", "birds", "lord of the rings characters", "breakfast foods"]
 SPREAD_CHOICES = [("Single card", "single"), ("Past · Present · Future", "three")]
 
 PAGE_ORDER = ["landing", "taro", "generate", "pick", "reading", "view"]
@@ -106,17 +107,62 @@ with open(os.path.join(ROOT, "frontend", "deckview.html"), encoding="utf-8") as
     _DECKVIEW_HTML = _f.read()
 
 
-def deck_iframe(deck: dict | None, nonce: int = 0) -> str:
+def _card_desc(c: dict) -> str:
+    """Short caption text for a card — its essence if the loremaster has written it,
+    else the (draft) upright meaning, trimmed."""
+    d = (c.get("essence") or c.get("upright_meaning") or "").strip()
+    d = d.replace("**", "").replace("*", "")  # drop raw markdown markers in the caption
+    return d[:200]
+
+
+def _status_paths(deck: dict):
+    dd = deck_dir(deck["deck_id"])
+    return os.path.join(dd, "art.json"), os.path.join(dd, "lore.json")
+
+
+def _write_json_atomic(path: str, data: dict) -> None:
+    tmp = path + ".tmp"
+    with open(tmp, "w", encoding="utf-8") as f:
+        json.dump(data, f)
+    os.replace(tmp, path)  # atomic → the poller never reads a half-written file
+
+
+def _write_art_status(deck: dict, done: bool) -> None:
+    """Live status the deck-view widget polls: which cards are painted (num → url)."""
+    art, _ = _status_paths(deck)
+    cards = {c["arcana_number"]: disp_url(c) for c in deck["cards"] if c.get("disp_path")}
+    _write_json_atomic(art, {"cards": cards, "done": done,
+                             "back": url_for(deck.get("back_disp") or deck.get("back_path"))})
+
+
+def _write_lore_status(deck: dict, done: bool) -> None:
+    """Live status the widget polls: each card's (refined) meaning."""
+    _, lore = _status_paths(deck)
+    cards = {c["arcana_number"]: {"essence": c.get("essence", ""),
+                                  "upright": c.get("upright_meaning", ""),
+                                  "reversed": c.get("reversed_meaning", "")}
+             for c in deck["cards"]}
+    _write_json_atomic(lore, {"cards": cards, "done": done})
+
+
+def deck_iframe(deck: dict | None, nonce: int = 0, live: bool = False,
+                art_url: str = "", lore_url: str = "") -> str:
     """The deck browser — a self-contained coverflow/overhead widget embedded via an
     iframe ``srcdoc`` (the whole widget HTML is inlined, with the deck's image URLs +
     names injected as base64 JSON in a global). Using srcdoc instead of a /viewer
     static mount keeps everything inside gradio's native server (ZeroGPU-compatible).
-    All swipe/flip/fade/toggle/lightbox is handled client-side in the widget."""
+    All swipe/flip/fade/toggle/lightbox is handled client-side in the widget.
+
+    live=True seeds the widget with names + (draft) descriptions and EMPTY art (a
+    shimmer placeholder per card); the widget then polls `art_url`/`lore_url` and
+    fills each card's art + refined meaning in as the two GPU phases finish."""
     if not deck or not deck.get("cards"):
         return "<div class='spread-empty'>No deck to show.</div>"
     data = {
         "back": url_for(deck.get("back_disp") or deck.get("back_path")),
-        "cards": [{"name": c["concept"], "arc": c.get("arcana_name", ""),
+        "live": bool(live), "artUrl": art_url, "loreUrl": lore_url,
+        "cards": [{"num": c["arcana_number"], "name": c["concept"],
+                   "arc": c.get("arcana_name", ""), "desc": _card_desc(c),
                    "front": disp_url(c), "full": full_url(c)}
                   for c in deck["cards"]],
     }
@@ -125,8 +171,8 @@ def deck_iframe(deck: dict | None, nonce: int = 0) -> str:
     doc = _DECKVIEW_HTML.replace("</head>", inject + "</head>", 1)
     srcdoc = html.escape(doc, quote=True)
     return (f"<iframe srcdoc='{srcdoc}' title='Deck' "
-            "style='width:100%;height:74vh;min-height:520px;border:0;display:block;"
-            "background:transparent;'></iframe>")
+            "style='width:100%;height:74vh;max-height:660px;min-height:520px;border:0;"
+            "display:block;background:transparent;'></iframe>")
 
 
 def zip_deck(deck: dict | None):
@@ -170,11 +216,29 @@ WORDS_FADE_CAP = 14.0  # never wait longer than this for a fade to finish
 
 def _fade(text: str, step: float = FADE_STEP, start: float = 0.0) -> str:
     """Wrap each word in a span that fades in on a staggered delay — the browser
-    animates the whole block in one render (no per-word server round-trips)."""
-    out = []
-    for i, w in enumerate(text.split()):
-        out.append(f"<span class='fw' style='animation-delay:{start + i * step:.2f}s'>"
-                   f"{html.escape(w)} </span>")
+    animates the whole block in one render (no per-word server round-trips).
+
+    Nemotron likes to emphasise with Markdown (**bold**, *italic*); rather than fight
+    it we honour it as a formatting cue. We split the text into styled runs and fade
+    word-by-word within them, so the effect and the HTML both stay valid."""
+    runs, pos = [], 0
+    for m in re.finditer(r"\*\*(.+?)\*\*|\*(.+?)\*", text, flags=re.DOTALL):
+        if m.start() > pos:
+            runs.append((text[pos:m.start()], False, False))
+        if m.group(1) is not None:
+            runs.append((m.group(1), True, False))
+        else:
+            runs.append((m.group(2), False, True))
+        pos = m.end()
+    if pos < len(text):
+        runs.append((text[pos:], False, False))
+    out, idx = [], 0
+    for seg, bold, ital in runs:
+        cls = "fw" + (" fwb" if bold else "") + (" fwi" if ital else "")
+        for w in seg.split():
+            out.append(f"<span class='{cls}' style='animation-delay:{start + idx * step:.2f}s'>"
+                       f"{html.escape(w)} </span>")
+            idx += 1
     return "".join(out)
 
 
@@ -203,10 +267,10 @@ def _text_col(d: dict, body_html: str) -> str:
     return f"<div class='text-col'>{head}{ess}{body}</div>"
 
 
-def _stage(back_url, completed, active=None, synth_html=""):
-    """active: (d, body_html, anim) or None. completed: list of (d, body_html).
-    The synthesis, when present, renders at the TOP (in the reading area) above the
-    list of already-read cards."""
+def _stage_active(back_url, active=None, synth_html=""):
+    """The TOP area: the currently-active card (+ its reading), or the synthesis.
+    Rendered ABOVE the Next button so Next always sits right under the live card —
+    the already-read history goes in _stage_done, below Next."""
     parts = []
     if active is not None:
         d, body, anim = active
@@ -214,13 +278,18 @@ def _stage(back_url, completed, active=None, synth_html=""):
                      f"{_flip_card(d, back_url, anim)}</div>{_text_col(d, body)}</div>")
     if synth_html:
         parts.append(f"<div id='fortune-box'>{synth_html}</div>")
-    if completed:
-        rows = "".join(f"<div class='done-row'><div class='card-col'>{_still_card(d)}</div>"
-                       f"{_text_col(d, body)}</div>" for d, body in completed)
-        parts.append(f"<div class='completed'>{rows}</div>")
     return f"<div class='reading-stage'>{''.join(parts)}</div>"
 
 
+def _stage_done(completed):
+    """The BOTTOM area: the list of already-read cards (below the Next button)."""
+    if not completed:
+        return ""
+    rows = "".join(f"<div class='done-row'><div class='card-col'>{_still_card(d)}</div>"
+                   f"{_text_col(d, body)}</div>" for d, body in completed)
+    return f"<div class='reading-stage'><div class='completed'>{rows}</div></div>"
+
+
 # Manual, reader-paced theatre (§14): "Draw" reveals the first card; a "Next" button
 # advances one beat at a time so people can read in their own time. Reading state
 # lives in a session dict carried in gr.State between clicks.
@@ -233,43 +302,51 @@ def _gpu_reading(deck, question, drawn):
     """Compute ALL card readings + the synthesis in ONE GPU session (the Nemotron
     GGUF can't be cached across separate ZeroGPU calls). Revealed progressively
     client-side afterwards. Returns (partials, synthesis)."""
+    from arcana.timing import record
+    import time as _t
     llm = get_llm()
     partials = []
+    tc = _t.time()
     for i in range(len(drawn)):
         try:
             partials.append(card_partial(deck, question, drawn, i, llm=llm))
         except Exception:
             partials.append("")
+    record("reading_cards", _t.time() - tc, {"n": len(drawn)})
+    ts = _t.time()
     try:
         synth = final_synthesis(deck, question, drawn, partials, llm=llm)
     except Exception as e:
         synth = f"(the synthesis slips away — {type(e).__name__})"
+    record("reading_synthesis", _t.time() - ts)
     return partials, synth
 
 
 def _reveal_card(sess):
     """Flip the card at sess['i'] into the active area and reveal its (already
-    computed) reading. Yields (stage_html, sess, next_button_update)."""
+    computed) reading. Yields (active_html, done_html, sess, next_button_update)."""
     drawn, back, i = sess["drawn"], sess["back"], sess["i"]
     d, completed = drawn[i], sess["completed"]
+    done_html = _stage_done(completed)
     label = "Next card  ▸" if i + 1 < len(drawn) else "Reveal the verdict  ▸"
     # flip + essence show first, then the deeper reading fades in a beat later
-    yield _stage(back, completed, active=(d, "", True)), sess, _next_btn(label)
+    yield _stage_active(back, active=(d, "", True)), done_html, sess, _next_btn(label)
     time.sleep(FLIP_BEAT)
     p = sess["partials_pre"][i] if i < len(sess.get("partials_pre", [])) else ""
     sess["last_p"] = p
     body = _fade(p) if p else ""
-    yield _stage(back, completed, active=(d, body, False)), sess, _next_btn(label)
+    yield _stage_active(back, active=(d, body, False)), done_html, sess, _next_btn(label)
 
 
 def do_draw(deck, question, spread, reversals):
     """Begin a reading: draw the spread, compute every card's reading on the GPU in
     one pass, then reveal card by card as the reader clicks Next."""
     if not deck:
-        yield "<div class='spread-empty'>Conjure or open a deck first.</div>", None, _next_btn(None)
+        yield ("<div class='spread-empty'>Conjure or open a deck first.</div>", "",
+               None, _next_btn(None))
         return
     drawn = draw_spread(deck, spread=spread, reversals=reversals)
-    yield ("<div class='spread-empty'>…the oracle contemplates the spread…</div>",
+    yield ("<div class='spread-empty'>…the oracle contemplates the spread…</div>", "",
            None, _next_btn(None))
     partials, synth = _gpu_reading(deck, question, drawn)
     sess = {"deck": deck, "drawn": drawn, "question": question,
@@ -281,10 +358,9 @@ def do_draw(deck, question, spread, reversals):
 def do_next(sess):
     """Advance the reading one beat (reader-paced)."""
     if not sess or sess.get("phase") != "card":
-        yield gr.update(), sess, _next_btn(None)
+        yield gr.update(), gr.update(), sess, _next_btn(None)
         return
-    # drop the current card to the list below, with its full reading (essence
-    # stands alone if the deeper text was unavailable)
+    # drop the current card to the history list below, with its full reading
     d = sess["drawn"][sess["i"]]
     lp = sess.get("last_p") or ""
     sess["completed"].append((d, f"<span>{html.escape(lp)}</span>" if lp else ""))
@@ -292,18 +368,18 @@ def do_next(sess):
         sess["i"] += 1
         yield from _reveal_card(sess)
         return
-    # all cards read — gather and reveal the synthesis at the top (reading area)
+    # all cards read — reveal the synthesis in the (top) active area
     sess["phase"] = "synth"
     back = sess["back"]
-    yield (_stage(back, sess["completed"],
-                  synth_html="<div class='syn-load'>…the oracle gathers the threads…</div>"),
-           sess, _next_btn(None))
+    done_html = _stage_done(sess["completed"])
+    yield (_stage_active(back, synth_html="<div class='syn-load'>…the oracle gathers the threads…</div>"),
+           done_html, sess, _next_btn(None))
     time.sleep(FLIP_BEAT)
     synth = sess.get("synth_pre") or "(the synthesis slips away)"
     sess["phase"] = "done"
-    yield (_stage(back, sess["completed"],
-                  synth_html=f"<h3>✦ The cards together</h3><div class='syn-body'>{_fade(synth)}</div>"),
-           sess, _next_btn(None))
+    yield (_stage_active(back, synth_html=f"<h3>✦ The cards together</h3>"
+                         f"<div class='syn-body'>{_fade(synth)}</div>"),
+           done_html, sess, _next_btn(None))
 
 # ----------------------------------------------------------------- generate
 def do_conjure(theme, style, custom):
@@ -311,42 +387,206 @@ def do_conjure(theme, style, custom):
     deck in the SAME Deck-View/Overhead browser used by View Deck (so you can flip
     through the new cards), with Read / Save actions there.
 
-    Outputs: gen_status, deck_state, vd_deck, vd_html, download_btn, *pages."""
+    Outputs: gen_status, deck_state, vd_deck, vd_html, download_btn, *pages,
+    read_btn, download_btn2(view_note)."""
     HOLD = (gr.update(),) * 4  # deck_state, vd_deck, vd_html, download_btn
+    # read_btn + view_note tail (grey out Read/Download while the deck is still painting)
+    TAIL_IDLE = (gr.update(), gr.update())
+    READ_BUSY = gr.update(interactive=False, value="🎴 Painting the deck…")
+    READ_DONE = gr.update(interactive=True, value="✦ Read this deck")
+    NOTE_BUSY = ("🎴 Painting the cards & writing the lore — the reading and download "
+                 "unlock once the whole deck is complete.")
 
     def stay(status):  # progress: update only the status line, stay on the generate page
-        return (status, *HOLD, *show("generate"))
+        return (status, *HOLD, *show("generate"), *TAIL_IDLE)
 
+    NOOP = (gr.update(),) * (5 + len(PAGE_ORDER) + 2)  # change nothing, keep the stream alive
     theme = (theme or "").strip()
     if not theme:
         yield stay("Name a theme to begin."); return
-    # PHASE 1 — the 30B mapping (its own GPU call); PHASE 2 — FLUX images (separate
-    # GPU call). Split so the 30B and the 9B image model never share the 48GB GPU.
+    # PHASE 1 — the mapping (its own GPU call): theme → 22 named cards with draft
+    # meanings + art briefs. As soon as it lands we jump STRAIGHT TO THE DECK VIEW.
+    t_map0 = time.time()
     deck = None
-    # STAGE 1 — generating the cards (the LLM mapping); shown as its own loader.
     for kind, payload, frac in _gpu_map(theme, style, custom):
-        if kind == "progress":
-            yield stay("<div class='gen-load'><div class='gen-spin'></div>"
-                       f"<h2>✦ Generating the cards</h2><p>{html.escape(payload)}</p>"
-                       f"<p class='gen-sub'>mapping <em>{html.escape(theme)}</em> onto the 22 arcana…</p></div>")
-        elif kind == "error":
+        if kind == "error":
             yield stay(f"⚠️ The conjuring faltered ({payload}). Try again."); return
+        elif kind == "progress":
+            yield stay(_loader("✦ Finding the cards", payload,
+                               f"mapping {html.escape(theme)} onto the 22 cards of the major arcana…"))
         elif kind == "done":
             deck = payload
     if not deck:
         yield stay("⚠️ The conjuring faltered (no deck). Try again."); return
-    # STAGE 2 — painting the cards (FLUX); card-by-card progress bar.
-    for kind, payload, frac in _gpu_images(deck):
-        if kind == "progress":
-            yield stay("<div class='gen-load'><h2>🎴 Painting the deck</h2>"
-                       f"<p>{html.escape(payload)}</p>"
-                       f"<div class='gen-bar'><div style='width:{int(frac * 100)}%'></div></div></div>")
-        elif kind == "error":
-            yield stay(f"⚠️ The painting faltered ({payload}). Try again."); return
-        elif kind == "done":
-            deck = payload
-    # open the freshly-made deck in the coverflow deck browser
-    yield ("", deck, deck, deck_iframe(deck, _next_nonce()), zip_deck(deck), *show("view"))
+    t_map = time.time() - t_map0
+
+    # Fan the 22 cards across the GPU slots, round-robin balanced.
+    by = {c["arcana_number"]: c for c in deck["cards"]}
+    nums = [c["arcana_number"] for c in deck["cards"]]
+    chunks = [c for c in (nums[i::PARALLEL_GPUS] for i in range(PARALLEL_GPUS)) if c]
+    NW = len(chunks)
+
+    def merge_fields(res, chunk, fields):
+        rb = {c["arcana_number"]: c for c in (res or {}).get("cards", [])}
+        for n in chunk:
+            src = rb.get(n, {})
+            for k in fields:
+                if src.get(k):
+                    by[n][k] = src[k]
+
+    # PHASE 2 — SCRIBE (parallel): generate all meanings + art prompts behind a LOADER
+    # (the deck view is withheld until the lore is fully written, per the new design).
+    t_scribe0 = time.time()
+
+    def scribe_tick(n):
+        pct = int(100 * n / NW)
+        bar = f"<div class='gen-bar'><div style='width:{pct}%'></div></div>"
+        return stay("<div class='gen-load'><div class='gen-spin'></div>"
+                    "<h2>✦ Writing the lore</h2><p>the scribe inks the 22 cards…</p>"
+                    f"<p class='gen-sub'>{n}/{NW} batches</p>{bar}</div>")
+    yield from _run_parallel(chunks, fn=lambda i, ch: _gpu_scribe(deck, ch),
+                             on_done=lambda res, ch: merge_fields(res, ch, _SCRIBE_OUT),
+                             tick=scribe_tick)
+    t_scribe = time.time() - t_scribe0
+
+    # Lore is done → OPEN THE REAL DECK VIEW now (names + full meanings); the art then
+    # lazy-loads card-by-card (the iframe polls art.json, which we rebuild from disk).
+    _write_art_from_disk(deck, done=False)
+    art_url = url_for(os.path.relpath(_status_paths(deck)[0], ROOT))
+    yield ("", deck, deck,
+           deck_iframe(deck, _next_nonce(), live=True, art_url=art_url, lore_url=""),
+           gr.update(interactive=False), *show("view"), READ_BUSY, NOTE_BUSY)
+
+    # PHASE 3 — PAINT (parallel): each tick we rebuild art.json from whatever card
+    # images exist on disk, so cards fill in INDIVIDUALLY as their files land (lazy),
+    # not in chunk-batches.
+    def merge_paint(res, ch):
+        merge_fields(res, ch, _PAINT_OUT)
+        for bk in ("back_path", "back_disp"):
+            if (res or {}).get(bk):
+                deck[bk] = res[bk]
+
+    def paint_tick(n):
+        _write_art_from_disk(deck, done=False)
+        return NOOP
+    t_paint0 = time.time()
+    yield from _run_parallel(chunks, fn=lambda i, ch: _gpu_paint(deck, ch, i == 0),
+                             on_done=merge_paint, tick=paint_tick)
+    _reconcile_from_disk(deck)  # rescue any cards a failed chunk left unmerged
+    _write_art_from_disk(deck, done=True)
+    t_paint = time.time() - t_paint0
+
+    from arcana.timing import record as _rec
+    _rec("conjure_total", t_map + t_scribe + t_paint,
+         {"map": round(t_map), "scribe": round(t_scribe), "paint": round(t_paint)})
+
+    timing_note = (f"⏱ mapping {t_map:.0f}s · scribe {t_scribe:.0f}s (×{NW}) · "
+                   f"painting {t_paint:.0f}s (×{NW}) · total {t_map + t_scribe + t_paint:.0f}s")
+    yield ("", deck, deck, deck_iframe(deck, _next_nonce()),
+           gr.update(value=zip_deck(deck), interactive=True), *show("view"),
+           READ_DONE, timing_note)
+
+
+_SCRIBE_OUT = ("essence", "upright_meaning", "reversed_meaning", "art_prompt")
+_PAINT_OUT = ("art_path", "disp_path", "full_path", "seed")
+# Fan-out width. ZeroGPU grants ~4-5 concurrent slots (fluctuating) for this account,
+# so 4 fits in one wave with minimal model-load overhead; higher just queues into extra
+# waves. Env-overridable for experiments.
+PARALLEL_GPUS = int(os.environ.get("PARALLEL_GPUS", "4"))
+
+
+def _run_parallel(chunks, fn, on_done, tick):
+    """Run fn(i, chunk) for each chunk on its own thread → concurrent @spaces.GPU
+    calls. As each finishes, on_done(result, chunk) merges it; each loop yields
+    tick(n_done) to refresh the UI / status while the GPUs work (keeps the Gradio
+    stream alive). Chunk errors are LOGGED (not swallowed) so a failed chunk is
+    visible — the caller reconciles from disk afterwards so its cards aren't lost."""
+    import concurrent.futures as _cf
+    with _cf.ThreadPoolExecutor(max_workers=len(chunks)) as ex:
+        futs = {ex.submit(fn, i, ch): ch for i, ch in enumerate(chunks)}
+        pending, n = set(futs), 0
+        while pending:
+            for f in [x for x in pending if x.done()]:
+                pending.discard(f)
+                try:
+                    on_done(f.result(), futs[f])
+                except Exception as e:
+                    print(f"[CHUNK_ERR] cards {futs[f]}: {type(e).__name__}: {e}", flush=True)
+                n += 1
+            yield tick(n)
+            time.sleep(0.4)
+
+
+def _reconcile_from_disk(deck: dict) -> dict:
+    """Fill any card's image paths from the files that ACTUALLY exist on disk. Guards
+    against a paint chunk that errored after saving files but before its result merged
+    — without this, such cards stay blank (shimmering) in the final deck view."""
+    dd = deck_dir(deck["deck_id"])
+    thumbs = os.path.join(dd, "thumbs")
+    for c in deck["cards"]:
+        base = f"{c['arcana_number']:02d}_{slugify(c['concept'])}"
+        for key, path in (("art_path", os.path.join(dd, base + ".png")),
+                          ("disp_path", os.path.join(thumbs, base + ".webp")),
+                          ("full_path", os.path.join(thumbs, base + ".full.webp"))):
+            if not c.get(key) and os.path.exists(path):
+                c[key] = os.path.relpath(path, ROOT)
+    for key, path in (("back_path", os.path.join(dd, "back.png")),
+                      ("back_disp", os.path.join(thumbs, "back.webp"))):
+        if not deck.get(key) and os.path.exists(path):
+            deck[key] = os.path.relpath(path, ROOT)
+    return deck
+
+
+def _write_art_from_disk(deck: dict, done: bool) -> None:
+    """Rebuild art.json from the card images that ACTUALLY exist on disk — so the
+    deck view fills in card-by-card (lazy) as each file lands, regardless of which
+    parallel chunk produced it. Disp path is deterministic from arcana#+concept."""
+    thumbs = os.path.join(deck_dir(deck["deck_id"]), "thumbs")
+    cards = {}
+    for c in deck["cards"]:
+        p = os.path.join(thumbs, f"{c['arcana_number']:02d}_{slugify(c['concept'])}.webp")
+        if os.path.exists(p):
+            cards[c["arcana_number"]] = url_for(os.path.relpath(p, ROOT))
+    bp = os.path.join(thumbs, "back.webp")
+    back = url_for(os.path.relpath(bp, ROOT)) if os.path.exists(bp) else ""
+    _write_json_atomic(_status_paths(deck)[0], {"cards": cards, "back": back, "done": done})
+
+
+def _loader(title: str, msg: str, sub: str) -> str:
+    return ("<div class='gen-load'><div class='gen-spin'></div>"
+            f"<h2>{title}</h2><p>{html.escape(msg)}</p>"
+            + (f"<p class='gen-sub'>{sub}</p>" if sub else "") + "</div>")
+
+
+def _conjure_grid(deck: dict, painted: dict, title: str, sub: str,
+                  show_desc: bool, frac: float | None = None) -> str:
+    """Progressive deck-view grid: every card shows its name immediately, its
+    description once the loremaster has written it, and its art the moment FLUX
+    finishes painting it (a shimmer placeholder until then)."""
+    cells = []
+    for c in deck["cards"]:
+        num = c["arcana_number"]
+        name = html.escape(c.get("concept", ""))
+        arc = html.escape(c.get("arcana_name", ""))
+        url = painted.get(num)
+        art = (f"<img src='{url}' alt='{name}' loading='lazy'/>" if url
+               else "<div class='cj-shim'></div>")
+        desc = ""
+        if show_desc:
+            d = c.get("essence") or c.get("upright_meaning", "")
+            if d:
+                desc = f"<p class='cj-desc'>{html.escape(d[:160])}</p>"
+        cells.append(
+            f"<div class='cj-card{' cj-lit' if url else ''}'>"
+            f"<div class='cj-art'>{art}</div>"
+            f"<div class='cj-meta'><span class='cj-arc'>{arc}</span>"
+            f"<span class='cj-name'>{name}</span>{desc}</div></div>")
+    bar = (f"<div class='gen-bar'><div style='width:{int((frac or 0) * 100)}%'></div></div>"
+           if frac is not None else "")
+    return ("<div class='cj-wrap'><div class='cj-head'>"
+            f"<div class='gen-spin'></div><h2>{title}</h2>"
+            f"<p class='gen-sub'>{sub}</p>{bar}</div>"
+            f"<div class='cj-grid'>{''.join(cells)}</div></div>")
 
 
 def _threaded_progress(work):
@@ -373,41 +613,285 @@ def _threaded_progress(work):
         yield ("done", st["result"], 1.0)
 
 
-@GPU(duration=600)
+@GPU(duration=400)
 def _gpu_map(theme, style, custom):
-    """Phase 1 (own GPU call): the 30B mapping (design + loremaster), no images.
-    600s: the 30B reasons for the designer AND the loremaster + first-call warm-up."""
-    from arcana.build import design_phase
+    """Phase 1 (own GPU call): the 30B designer mapping ONLY — theme → 22 named cards
+    with justifications, draft meanings, and art briefs. Returns fast enough to jump
+    straight to the deck view; the loremaster + FLUX then run in parallel. 400s covers
+    first-call warm-up + the single designer pass."""
+    from arcana.build import map_phase
     yield from _threaded_progress(
-        lambda emit: design_phase(theme, visual_style=style, custom_style=custom,
-                                  progress=emit))
+        lambda emit: map_phase(theme, visual_style=style, custom_style=custom, progress=emit))
+
+
+@GPU(duration=240)
+def _gpu_scribe(deck, subset=None):
+    """Generative scribe (one parallel chunk): invent meaning + art_prompt for the
+    `subset` of arcana numbers (default all 22). Returns the deck with that subset
+    filled; the MAIN process merges chunks + writes lore.json (avoids 4 workers
+    clobbering one status file)."""
+    from arcana.build import scribe_phase
+    scribe_phase(deck, subset=subset)
+    return deck
+
+
+@GPU(duration=200)
+def _gpu_paint(deck, subset, paint_back=False):
+    """Paint one parallel chunk of cards (+ the deck-back if paint_back). Saves images
+    to the shared disk and returns the deck with that subset's paths filled; the MAIN
+    process merges + writes art.json."""
+    from arcana.build import paint_subset
+    paint_subset(deck, subset, paint_back=paint_back)
+    return deck
+
+
+@GPU(duration=400)
+def _gpu_mapdiag(theme):
+    """FIX TEST v2: force the exact schema with a JSON-schema GRAMMAR (prevents tool
+    calls, malformed JSON, and field drift all at once) on the STRIPPED mapping
+    (arcana_number+concept+justification only). 3 runs to gauge reliability."""
+    import json, time as _t
+    from arcana.gpu_models import _get_llama, _DEF_30B
+    theme = theme or "Greek mythology"
+    llm = _get_llama(_DEF_30B[0], _DEF_30B[1], 16384)
+    SCHEMA = {
+        "type": "object", "required": ["cards"],
+        "properties": {"cards": {"type": "array", "items": {
+            "type": "object", "required": ["arcana_number", "concept", "justification"],
+            "properties": {
+                "arcana_number": {"type": "integer"},
+                "concept": {"type": "string"},
+                "justification": {"type": "string"}}}}}}
+    sysmsg = (
+        "Map the 22 Major Arcana onto concepts from the given theme. For EVERY arcana 0-21, "
+        "pick ONE DISTINCT in-theme concept (a short proper noun/name, NOT a sentence) whose "
+        "meaning rhymes with that archetype, plus a one-line justification. Output JSON.")
+    usr = f"Theme: {theme}\nMap all 22 arcana (0 through 21). Each concept must be unique."
+    blocks = []
+    for run in range(3):
+        t = _t.time()
+        try:
+            out = llm.create_chat_completion(
+                messages=[{"role": "system", "content": sysmsg},
+                          {"role": "user", "content": usr}],
+                response_format={"type": "json_object", "schema": SCHEMA},
+                max_tokens=5000, temperature=0.4)
+            raw = (out["choices"][0]["message"]["content"] or "")
+        except Exception as e:
+            blocks.append(f"run{run+1}: GEN ERROR {type(e).__name__}: {str(e)[:90]}"); continue
+        dt = _t.time() - t
+        info = [f"run{run+1}: {dt:.0f}s len={len(raw)}"]
+        try:
+            cards = json.loads(raw).get("cards", [])
+            cons = [(c.get("concept") or "").strip() for c in cards]
+            nums = sorted(c.get("arcana_number") for c in cards if isinstance(c.get("arcana_number"), int))
+            info.append(f"PARSED ✓ cards={len(cards)} nums_ok={nums==list(range(22))} "
+                        f"empty={sum(1 for x in cons if not x)} dup={len(cons)-len(set(x.lower() for x in cons))}")
+            info.append("concepts: " + " | ".join(cons))
+        except Exception as e:
+            info.append(f"PARSE FAIL {type(e).__name__}: {str(e)[:90]} | TAIL " + raw[-180:].replace("\n", "\\n"))
+        blocks.append("\n".join(info))
+    return "\n\n====\n\n".join(blocks)
+
+
+@GPU(duration=40)
+def _gpu_ping(tag, hold):
+    """A trivial GPU task that holds its allocation for `hold` seconds — used to test
+    whether ZeroGPU grants ONE user TWO concurrent GPU slots (the #3 parallel
+    text+image design hinges on this)."""
+    import time as _t
+    t0 = _t.time()
+    try:
+        import torch
+        x = torch.ones(1, device="cuda"); _ = float((x + 1).sum().item())
+    except Exception as e:
+        return f"{tag}|ERR|{type(e).__name__}:{str(e)[:60]}"
+    _t.sleep(hold)
+    return f"{tag}|{t0:.3f}|{_t.time():.3f}"
+
+
+def _concurrency_probe():
+    """Fire K @GPU pings at once and report the MAX number that ran simultaneously —
+    i.e. how many concurrent ZeroGPU slots this account actually gets. Decides how far
+    we can parallelize the meaning/art agent and the painting."""
+    import time as _t, concurrent.futures as _cf
+    HOLD, K = 7.0, 4
+    t_start = _t.time()
+    with _cf.ThreadPoolExecutor(max_workers=K) as ex:
+        futs = [ex.submit(_gpu_ping, str(i), HOLD) for i in range(K)]
+        res = []
+        for f in futs:
+            try:
+                res.append(f.result())
+            except Exception as e:
+                res.append(f"X|ERR|{type(e).__name__}:{str(e)[:50]}")
+    total = _t.time() - t_start
+    ivs, fails = [], 0
+    for r in res:
+        p = r.split("|")
+        if len(p) >= 3 and p[1] == "ERR":
+            fails += 1
+        else:
+            try:
+                ivs.append((float(p[1]), float(p[2])))
+            except Exception:
+                fails += 1
+    # sweep line: max overlapping intervals
+    ev = []
+    for s, e in ivs:
+        ev += [(s, 1), (e, -1)]
+    ev.sort()
+    cur = mx = 0
+    for _, d in ev:
+        cur += d; mx = max(mx, cur)
+    return (f"max_concurrent_gpus={mx} of {K} requested  (failed/rejected={fails})  "
+            f"total={total:.1f}s\nintervals={[(round(s, 1), round(e, 1)) for s, e in ivs]}")
+
+
+@GPU(duration=400)
+def _gpu_scribetest(theme):
+    """New pipeline check: designer (mapping+justification only) → generative scribe
+    (meaning + art). Reports timings, the mapping, and the scribe's meanings + ART
+    prompts for the religion-prone archetypes (Hierophant/Death/Temperance/Judgement)
+    — the regression risk from re-splitting meaning/art into a separate agent."""
+    import time as _t
+    from arcana import designer
+    from arcana.build import map_phase, scribe_phase
+    theme = theme or "Greek mythology"
+    t = _t.time(); deck = map_phase(theme); tmap = _t.time() - t
+    t = _t.time(); scribe_phase(deck); tsc = _t.time() - t
+    by = {c["arcana_number"]: c for c in deck["cards"]}
+    out = [f"THEME: {theme}  |  map={tmap:.0f}s (attempts={getattr(designer,'LAST_ATTEMPTS','?')})"
+           f"  |  scribe={tsc:.0f}s",
+           "\nCONCEPTS: " + " | ".join(c["concept"] for c in deck["cards"])]
+    for n in (5, 13, 14, 20):
+        c = by.get(n, {})
+        out.append(f"\n[{n}] {c.get('concept','?')}")
+        out.append(f"  essence: {c.get('essence','')}")
+        out.append(f"  upright: {c.get('upright_meaning','')[:220]}")
+        out.append(f"  ART   : {c.get('art_prompt','')[:260]}")
+    return "\n".join(out)
+
+
+@GPU(duration=400)
+def _gpu_loretest(theme):
+    """Side-by-side: the DESIGNER's draft meanings vs the LOREMASTER's refined ones,
+    for a spread of representative cards — to judge whether the loremaster pass earns
+    its keep or whether the designer drafts are already better/more detailed."""
+    from arcana.designer import design_deck
+    from arcana.loremaster import refine_deck
+    theme = theme or "Greek mythology"
+    deck = design_deck(theme)
+    draft = {c["arcana_number"]: dict(concept=c["concept"],
+                                      up=c["upright_meaning"], rev=c["reversed_meaning"])
+             for c in deck["cards"]}
+    refine_deck(deck)  # mutates meanings in place
+    fin = {c["arcana_number"]: dict(up=c["upright_meaning"], rev=c["reversed_meaning"],
+                                    ess=c.get("essence", "")) for c in deck["cards"]}
+    out = [f"THEME: {theme}\n(draft = designer • refined = loremaster)\n"]
+    for n in (0, 6, 10, 13, 16, 21):
+        d, f = draft.get(n, {}), fin.get(n, {})
+        out.append(f"\n========== [{n}] {d.get('concept','?')} ==========")
+        out.append(f"UPRIGHT  draft  : {d.get('up','')}")
+        out.append(f"UPRIGHT  refined: {f.get('up','')}")
+        out.append(f"REVERSED draft  : {d.get('rev','')}")
+        out.append(f"REVERSED refined: {f.get('rev','')}")
+        out.append(f"essence (loremaster only): {f.get('ess','')}")
+    # rough length comparison across ALL 22 cards
+    da = sum(len(v["up"]) for v in draft.values()) / 22
+    fa = sum(len(v["up"]) for v in fin.values()) / 22
+    out.append(f"\n--- avg upright length: draft={da:.0f} chars · refined={fa:.0f} chars ---")
+    return "\n".join(out)
 
 
 @GPU(duration=600)
 def _gpu_maptest(theme):
-    """Quota-cheap mapping-only probe (no images): returns timing + a quality check
-    so I can tune the 30B mapping without paying for the 24-image paint each run."""
+    """Quota-cheap mapping-only probe (no images): breaks the LLM phase into
+    warm-up vs designer (with retry count) vs loremaster, so we can see EXACTLY
+    where the minutes go."""
     import time as _t
-    from arcana.build import design_phase
-    t0 = _t.time()
+    from arcana import designer
+    from arcana.designer import design_deck
+    from arcana.loremaster import refine_deck
+    from arcana.gpu_models import llama_map
+    theme = theme or "Greek mythology"
+    L = []
+    # 1) warm up the 8B mapper in isolation (load + first-inference JIT)
+    t = _t.time()
+    try:
+        llama_map("Reply with one tiny JSON object.", "Output {\"ok\": 1}", max_tokens=40)
+    except Exception as e:
+        L.append(f"warmup ERR {type(e).__name__}")
+    L.append(f"map-model warmup(load+1st gen)={_t.time()-t:.0f}s")
+    # 2) designer mapping (now warm) — note attempt count
+    t = _t.time()
+    try:
+        deck = design_deck(theme)
+    except Exception as e:
+        return " | ".join(L) + f" | designer FAILED {type(e).__name__}: {str(e)[:120]}"
+    L.append(f"designer={_t.time()-t:.0f}s attempts={getattr(designer,'LAST_ATTEMPTS','?')}")
+    # 3) loremaster pass
+    t = _t.time()
     try:
-        deck = design_phase(theme or "Greek mythology")
+        deck = refine_deck(deck)
     except Exception as e:
-        return f"FAILED in {_t.time()-t0:.0f}s: {type(e).__name__}: {e}"
-    dt = _t.time() - t0
-    cards = deck.get("cards", [])
-    cs = [c.get("concept", "") for c in cards]
-    empties = sum(1 for x in cs if not x.strip())
-    dups = len(cs) - len(set(cs))
-    sample = "; ".join(f"{c['arcana_number']}:{c['concept']}" for c in cards[:8])
-    return f"{dt:.0f}s | {len(cards)} cards | empties={empties} dups={dups} | {sample}"
+        L.append(f"loremaster FAILED {type(e).__name__}")
+    else:
+        L.append(f"loremaster={_t.time()-t:.0f}s")
+    cs = [c.get("concept", "") for c in deck.get("cards", [])]
+    L.append(f"cards={len(cs)} empties={sum(1 for x in cs if not x.strip())} dups={len(cs)-len(set(cs))}")
+    out = " | ".join(L)
+    out += "\n\nCONCEPTS: " + " | ".join(cs)
+    by_n = {c.get("arcana_number"): c for c in deck.get("cards", [])}
+    sample = by_n.get(13)
+    if sample:
+        out += (f"\n\nSAMPLE (Death→{sample.get('concept')}): "
+                f"{sample.get('upright_meaning','')[:240]}")
+    # art prompts for the religion-prone archetypes (Hierophant/Temperance/Judgement)
+    for n in (5, 14, 20):
+        c = by_n.get(n)
+        if c:
+            out += (f"\n\nART[{n} {c.get('arcana_name')}→{c.get('concept')}]: "
+                    f"{c.get('art_prompt','')[:300]}")
+    return out
 
 
 @GPU(duration=300)
 def _gpu_images(deck):
-    """Phase 2 (own GPU call): paint back + 22 cards with FLUX (no LLM resident)."""
+    """Phase 2 (own GPU call): paint back + 22 cards with FLUX (no LLM resident).
+    Streams each finished card's display URL as it's painted so the deck-view grid
+    can fill in card-by-card. paint_phase mutates `deck` in this worker; we scan it
+    each tick and ship the ready cards' URLs (the saved files are served by the main
+    process). Yields ('paint', {msg, cards:[{num,url}], back}, frac) then ('done', deck)."""
     from arcana.build import paint_phase
-    yield from _threaded_progress(lambda emit: paint_phase(deck, progress=emit))
+    st = {"msg": "…", "frac": 0.0, "done": False, "result": None, "err": None}
+
+    def run():
+        try:
+            st["result"] = paint_phase(deck, lambda m, f: st.update(msg=m, frac=f))
+        except Exception as e:
+            st["err"] = e
+        finally:
+            st["done"] = True
+
+    def snapshot():
+        cards = [{"num": c["arcana_number"], "url": disp_url(c)}
+                 for c in deck["cards"] if c.get("disp_path")]
+        return {"msg": st["msg"], "cards": cards,
+                "back": url_for(deck.get("back_disp") or deck.get("back_path"))}
+
+    threading.Thread(target=run, daemon=True).start()
+    while not st["done"]:
+        _write_art_status(deck, done=False)  # live status the deck view polls
+        yield ("paint", snapshot(), min(st["frac"], 0.99))
+        time.sleep(0.4)
+    if st["err"] or st["result"] is None:
+        _write_art_status(deck, done=True)   # stop the poller even on failure
+        why = f"{type(st['err']).__name__}: {st['err']}" if st["err"] else "no result"
+        yield ("error", why[:300], 0.0); return
+    _write_art_status(deck, done=True)
+    yield ("paint", snapshot(), 1.0)
+    yield ("done", st["result"], 1.0)
 
 
 def toggle_custom(style):
@@ -422,15 +906,21 @@ def _next_nonce():
 
 
 def open_picked(deck_id, mode):
-    """Outputs: deck_state, vd_deck, vd_html, download_btn, *pages."""
+    """Outputs: deck_state, vd_deck, vd_html, download_btn, *pages, read_btn, view_note.
+    Opening a (complete) deck always re-enables Read/Download — in case a prior
+    conjure was interrupted mid-paint and left them greyed out."""
+    read_on = gr.update(interactive=True, value="✦ Read this deck")
     deck = load_deck(deck_id) if deck_id else None
     if not deck:
-        return (gr.update(), gr.update(), gr.update(), gr.update(), *show("pick"))
+        return (gr.update(), gr.update(), gr.update(), gr.update(), *show("pick"),
+                gr.update(), gr.update())
     if mode == "view":
         return (gr.update(), deck, deck_iframe(deck, _next_nonce()),
-                zip_deck(deck), *show("view"))
+                gr.update(value=zip_deck(deck), interactive=True), *show("view"),
+                read_on, "")
     # read mode → straight to the reading room
-    return (deck, gr.update(), gr.update(), gr.update(), *show("reading"))
+    return (deck, gr.update(), gr.update(), gr.update(), *show("reading"),
+            read_on, "")
 
 
 def read_this_deck(deck):
@@ -542,6 +1032,44 @@ button.primary, .big-btn { background:linear-gradient(135deg,#9a7b2e,#d8b15a) !i
   border-radius:6px; overflow:hidden; }
 .gen-bar > div { height:100%; background:linear-gradient(90deg,#9a7b2e,#d8b15a);
   transition:width .35s ease; }
+/* progressive conjure grid (deck view fills in as names/desc/art arrive) */
+.cj-wrap { padding:14px 8px 26px; }
+.cj-head { text-align:center; margin-bottom:18px; }
+.cj-head h2 { font-family:'Cinzel Decorative',serif; color:#d8b15a !important;
+  font-size:2.3rem !important; margin:12px 0 6px; }
+.cj-head .gen-sub { color:#9a8f70 !important; font-size:1.45rem !important;
+  font-style:italic; }
+.cj-head .gen-bar { max-width:440px; }
+.cj-grid { display:grid; grid-template-columns:repeat(auto-fill,minmax(150px,1fr));
+  gap:14px; max-width:1180px; margin:0 auto; }
+.cj-card { background:rgba(20,16,30,.55); border:1px solid rgba(216,177,90,.20);
+  border-radius:10px; overflow:hidden; display:flex; flex-direction:column;
+  opacity:.55; transition:opacity .5s ease, border-color .5s ease; }
+.cj-card.cj-lit { opacity:1; border-color:rgba(216,177,90,.5); }
+.cj-art { aspect-ratio:3/5; position:relative; background:rgba(216,177,90,.04); }
+.cj-art img { width:100%; height:100%; object-fit:cover; display:block;
+  animation:cjfade .6s ease; }
+@keyframes cjfade { from { opacity:0; } to { opacity:1; } }
+.cj-shim { position:absolute; inset:0; background:linear-gradient(100deg,
+  rgba(216,177,90,.05) 30%, rgba(216,177,90,.16) 50%, rgba(216,177,90,.05) 70%);
+  background-size:220% 100%; animation:cjshim 1.4s linear infinite; }
+@keyframes cjshim { to { background-position:-220% 0; } }
+.cj-meta { padding:8px 10px 11px; }
+.cj-arc { display:block; color:#9a8f70 !important; font-size:1.0rem !important;
+  letter-spacing:.04em; text-transform:uppercase; }
+.cj-name { display:block; font-family:'Cinzel Decorative',serif;
+  color:#e9d9a8 !important; font-size:1.45rem !important; line-height:1.2; margin-top:2px; }
+.cj-desc { color:#bcae86 !important; font-size:1.12rem !important; font-style:italic;
+  line-height:1.35 !important; margin:5px 0 0 !important; }
+/* suppress Gradio's pulsing blue/orange "generating" border-box on components
+   while an event streams (we have our own loaders) */
+.gradio-container .generating,
+.gradio-container .block.generating,
+.gradio-container *.generating {
+  border-color: transparent !important; box-shadow: none !important;
+  animation: none !important; }
+.gradio-container .generating::before, .gradio-container .generating::after {
+  display: none !important; animation: none !important; }
 #chips { flex-wrap:wrap !important; gap:6px !important; justify-content:center; }
 #chips .secondary { border-radius:999px !important; font-size:1.7rem !important; padding:8px 20px !important; }
 #deck img, #preview img { border-radius:8px; box-shadow:0 6px 20px rgba(0,0,0,.55); }
@@ -574,6 +1102,8 @@ button.primary, .big-btn { background:linear-gradient(135deg,#9a7b2e,#d8b15a) !i
 .syn-load { font-style:italic; color:#cdbf93; font-size:2rem; text-align:center; padding:10px; }
 /* word fade-in (§2) — each word eases in on a staggered delay */
 .fw { opacity:0; display:inline; animation:fadeWord .7s ease forwards; }
+.fwb { font-weight:700; color:#e9d2a0; }   /* Nemotron's **bold** as emphasis */
+.fwi { font-style:italic; }
 @keyframes fadeWord { from { opacity:0; } to { opacity:1; } }
 /* input contrast — light text on dark fields, never yellow-on-white (§4) */
 .gradio-container textarea, .gradio-container input, .gradio-container select,
@@ -588,6 +1118,9 @@ button.primary, .big-btn { background:linear-gradient(135deg,#9a7b2e,#d8b15a) !i
   background: rgba(243,230,196,.85) !important; border:1px solid var(--gold) !important;
   border-radius:4px !important; appearance:auto !important; -webkit-appearance:checkbox !important;
   opacity:1 !important; cursor:pointer; }
+/* "Allow reversals": nudge right + tighter wrap between the two words */
+#rev-box { margin-left:10px !important; }
+#rev-box label, #rev-box label span { line-height:1.12 !important; }
 /* dropdown popup + options — never yellow-on-white (§5) */
 .gradio-container ul[role="listbox"], .gradio-container .options, .gradio-container .option,
 .gradio-container li[role="option"], .gradio-container li.item, .gradio-container [class*="options"] {
@@ -712,18 +1245,17 @@ def build_demo() -> gr.Blocks:
                 placeholder="Name anything to build a tarot deck from — a field, a world, a "
                             "feeling… e.g. Greek mythology, the deep sea, jazz, office life",
                 show_label=False, value="", max_lines=1)
-            gr.Markdown("*…or tap an example to conjure one live (every card generated "
-                        "fresh):*", elem_classes=["status"])
+            gr.Markdown("*…or tap an example:*", elem_classes=["status"])
             with gr.Row(elem_id="chips"):
                 chips = [gr.Button(t, size="sm", elem_classes=["secondary"]) for t in EXAMPLE_THEMES]
-            with gr.Row():
-                style = gr.Dropdown(STYLE_CHOICES, value="rider-waite-smith",
-                                    label="Visual style", scale=3)
-                # toggling a CONTAINER's visibility is reliable here (unlike a bare
-                # Textbox) — created visible so it mounts; hidden on entry; shown for Custom.
-                with gr.Column(visible=True, scale=4) as custom_box:
-                    custom = gr.Textbox(label="Describe your style",
-                                        placeholder=CUSTOM_PLACEHOLDER, max_lines=1)
+            # full-width dropdown; the custom-style box unfurls BELOW it (stacked),
+            # and only when "Custom…" is chosen — hidden by default so it never shows
+            # spuriously (e.g. during a conjure).
+            style = gr.Dropdown(STYLE_CHOICES, value="rider-waite-smith",
+                                label="Visual style")
+            with gr.Column(visible=False) as custom_box:
+                custom = gr.Textbox(label="Describe your style",
+                                    placeholder=CUSTOM_PLACEHOLDER, max_lines=1)
             conjure = gr.Button("✦ Conjure the deck", elem_classes=["big-btn"])
             gen_status = gr.Markdown("", elem_classes=["status"])
             gen_back = gr.Button("↩ Back", scale=1, elem_classes=["secondary"])
@@ -747,12 +1279,13 @@ def build_demo() -> gr.Blocks:
                 spread = gr.Dropdown(SPREAD_CHOICES, value="three", label="Spread",
                                      scale=3, min_width=260)
                 reversals = gr.Checkbox(value=True, label="Allow reversals",
-                                        scale=2, min_width=220)
+                                        scale=2, min_width=220, elem_id="rev-box")
             draw = gr.Button("✦ Draw the cards", elem_classes=["big-btn"])
             stage = gr.HTML("<div class='spread-empty'>Pose your question, then draw.</div>",
                             elem_id="stage")
-            with gr.Row(elem_id="next-row"):
-                next_btn = gr.Button("Next card  ▸", visible=False, elem_classes=["big-btn"])
+            next_btn = gr.Button("Next card  ▸", visible=False, elem_classes=["big-btn"],
+                                 elem_id="next-btn")
+            stage_done = gr.HTML("", elem_id="stage-done")  # read-history, below Next
             with gr.Row():
                 save_in_read = gr.Button("✦ Save this deck", scale=1, elem_classes=["secondary"])
                 read_back = gr.Button("↩ Back to start", scale=1, elem_classes=["secondary"])
@@ -791,25 +1324,28 @@ def build_demo() -> gr.Blocks:
         style.change(toggle_custom, style, custom_box)
         # example theme chips — one click sets the theme AND conjures it from
         # scratch (the examples ARE live demos: every card is freshly generated).
+        # example chips just FILL the theme box (press Conjure to start) — they no
+        # longer auto-conjure
         for chip, t in zip(chips, EXAMPLE_THEMES):
-            chip.click(lambda t=t: t, None, theme).then(
-                do_conjure, [theme, style, custom],
-                [gen_status, deck_state, vd_deck, vd_html, download_btn, *pages])
+            chip.click(lambda t=t: (t, f"“{t}” — press ✦ Conjure to begin."),
+                       None, [theme, gen_status])
 
         # generate → opens the new deck in the Deck-View/Overhead browser (pg_view)
         conjure.click(do_conjure, [theme, style, custom],
-                      [gen_status, deck_state, vd_deck, vd_html, download_btn, *pages])
+                      [gen_status, deck_state, vd_deck, vd_html, download_btn, *pages,
+                       read_btn, view_note])
 
         # pick → open
         pick_refresh.click(lambda: gr.update(choices=deck_choices()), None, pick_dd)
         pick_open.click(open_picked, [pick_dd, pick_mode],
-                        [deck_state, vd_deck, vd_html, download_btn, *pages])
+                        [deck_state, vd_deck, vd_html, download_btn, *pages,
+                         read_btn, view_note])
         read_btn.click(read_this_deck, vd_deck, [deck_state, *pages])
 
         # reading
         draw.click(do_draw, [deck_state, question, spread, reversals],
-                   [stage, reading_sess, next_btn])
-        next_btn.click(do_next, reading_sess, [stage, reading_sess, next_btn])
+                   [stage, stage_done, reading_sess, next_btn])
+        next_btn.click(do_next, reading_sess, [stage, stage_done, reading_sess, next_btn])
         save_in_read.click(save_current, deck_state, save_note)
 
         # pages are created visible=True so gallery components mount cleanly
@@ -849,6 +1385,49 @@ def build_demo() -> gr.Blocks:
         _mt_theme = gr.Textbox("Greek mythology", visible=False)
         _mt_out = gr.Textbox(visible=False)
         gr.Button(visible=False).click(_gpu_maptest, _mt_theme, _mt_out, api_name="maptest")
+        _md_theme = gr.Textbox("Greek mythology", visible=False)
+        _md_out = gr.Textbox(visible=False)
+        gr.Button(visible=False).click(_gpu_mapdiag, _md_theme, _md_out, api_name="mapdiag")
+        _cc_out = gr.Textbox(visible=False)
+        gr.Button(visible=False).click(_concurrency_probe, None, _cc_out, api_name="concurrency")
+
+        def _imgdiag():
+            """Run the FLUX CPU preload and surface any error (the startup thread
+            swallows it). CPU-only construct + download; no GPU needed."""
+            import time as _t, traceback
+            from arcana import gpu_models as _gm
+            t = _t.time()
+            try:
+                p = _gm.preload_pipe()
+                return f"preload OK in {_t.time()-t:.0f}s: {type(p).__name__} (model={_gm.IMAGE_MODEL})"
+            except Exception as e:
+                return (f"preload FAILED after {_t.time()-t:.0f}s (model={_gm.IMAGE_MODEL}): "
+                        f"{type(e).__name__}: {e}\n\n" + traceback.format_exc()[-1400:])
+        _id_out = gr.Textbox(visible=False)
+        gr.Button(visible=False).click(_imgdiag, None, _id_out, api_name="imgdiag")
+
+        def _timings():
+            """Recent live-pipeline stage timings (most recent last). Reads the
+            shared JSONL the @spaces.GPU workers append to, so it reflects NATURAL
+            runs, not just diagnostics. Also grep the Space logs for '[TIMING]'."""
+            from arcana.timing import recent
+            rows = recent(50)
+            if not rows:
+                return "no timings recorded yet — conjure or read a deck first."
+            out = []
+            for r in rows:
+                extra = " ".join(f"{k}={v}" for k, v in r.items()
+                                 if k not in ("ts", "stage", "secs"))
+                out.append(f"{r.get('stage',''):<22} {r.get('secs',0):>7.1f}s  {extra}")
+            return "\n".join(out)
+        _tm_out = gr.Textbox(visible=False)
+        gr.Button(visible=False).click(_timings, None, _tm_out, api_name="timings")
+        _lt_theme = gr.Textbox("Greek mythology", visible=False)
+        _lt_out = gr.Textbox(visible=False)
+        gr.Button(visible=False).click(_gpu_loretest, _lt_theme, _lt_out, api_name="loretest")
+        _st_theme = gr.Textbox("Greek mythology", visible=False)
+        _st_out = gr.Textbox(visible=False)
+        gr.Button(visible=False).click(_gpu_scribetest, _st_theme, _st_out, api_name="scribetest")
 
     return demo
 

arcana/build.py

@@ -16,13 +16,15 @@ import os
 import time
 from typing import Callable
 
+from . import designer as _designer
 from .archetypes import ROMAN_BY_NUMBER
 from .compositor import compose_card
 from .designer import design_deck
 from .imagegen import get_imagegen
 from .llm import get_llm
-from .loremaster import refine_deck
+from .loremaster import refine_deck, scribe_deck
 from .styles import resolve_style
+from .timing import clock, record
 
 ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
 DECKS_DIR = os.path.join(ROOT, "decks")
@@ -101,13 +103,13 @@ def _back_prompt(style_suffix: str) -> str:
 
 
 # ------------------------------------------------------------------ build
-def design_phase(theme: str, visual_style: str = "rider-waite-smith",
-                 custom_style: str | None = None,
-                 progress: Progress | None = None) -> dict:
-    """LLM phase ONLY (the 30B mapping + loremaster). Returns a deck dict with
-    concepts + meanings but NO images yet. Split out so it can run in its own
-    @spaces.GPU call — the 30B and the FLUX image model are too big to share the
-    48GB GPU, so we never load them together."""
+def map_phase(theme: str, visual_style: str = "rider-waite-smith",
+              custom_style: str | None = None,
+              progress: Progress | None = None) -> dict:
+    """Mapping ONLY (the 30B designer): theme -> 22 archetype→concept mappings with
+    justifications, no meanings/art/images yet. Split from the loremaster so the UI
+    can reveal the card NAMES the instant the mapping lands (the loremaster's
+    meanings + art briefs follow in the same GPU call, no model reload)."""
     def emit(msg, frac):
         if progress:
             progress(msg, frac)
@@ -118,16 +120,10 @@ def design_phase(theme: str, visual_style: str = "rider-waite-smith",
     os.makedirs(deck_dir(deck_id), exist_ok=True)
     seed_base = _seed_base(theme, style_id)
 
-    llm = get_llm()
     emit("Consulting the deck designer…", 0.05)
-    deck = design_deck(theme, llm=llm)
-    if os.environ.get("SKIP_LOREMASTER", "").lower() not in ("1", "true", "yes"):
-        emit("The loremaster reinterprets the cards…", 0.10)
-        try:
-            deck = refine_deck(deck, llm=llm)
-        except Exception:
-            pass  # keep the designer's draft meanings if refinement hiccups
-
+    with clock("mapping") as c:
+        deck = design_deck(theme, llm=get_llm())
+        c.extra = {"attempts": getattr(_designer, "LAST_ATTEMPTS", "?")}
     deck.update({
         "deck_id": deck_id, "theme": theme, "visual_style": style_id,
         "style_suffix": style_suffix, "seed_base": seed_base,
@@ -135,33 +131,63 @@ def design_phase(theme: str, visual_style: str = "rider-waite-smith",
     return deck
 
 
-def paint_phase(deck: dict, progress: Progress | None = None) -> dict:
-    """Image phase ONLY (FLUX). Paints the back + 22 cards into the deck dir and
-    fills in the image paths. Runs in its own @spaces.GPU call (see design_phase)."""
+def scribe_phase(deck: dict, subset: list[int] | None = None,
+                 progress: Progress | None = None) -> dict:
+    """Scribe: GENERATE meaning + art_prompt for the cards (default all 22; `subset`
+    for parallel chunking). MANDATORY — the designer outputs only the mapping, so the
+    meanings AND art come solely from here; a failure surfaces (scribe self-repairs
+    once). Mutates and returns the deck dict."""
     def emit(msg, frac):
         if progress:
             progress(msg, frac)
+    emit("The scribe writes the lore and the art…", 0.10)
+    with clock("scribe", {"n": len(subset) if subset is not None else 22}):
+        return scribe_deck(deck, subset=subset, llm=get_llm())
+
+
+# back-compat alias
+def lore_phase(deck: dict, progress: Progress | None = None) -> dict:
+    return scribe_phase(deck, progress=progress)
+
+
+def design_phase(theme: str, visual_style: str = "rider-waite-smith",
+                 custom_style: str | None = None,
+                 progress: Progress | None = None) -> dict:
+    """LLM phase (mapping + scribe) in one go — for non-streaming callers.
+    Returns a deck dict with concepts + meanings + art briefs but NO images yet."""
+    deck = map_phase(theme, visual_style, custom_style, progress=progress)
+    return scribe_phase(deck, progress=progress)
 
+
+def paint_subset(deck: dict, nums: list[int], paint_back: bool = False,
+                 progress: Progress | None = None) -> dict:
+    """Paint a SUBSET of the deck's cards (by arcana number), saving each card's PNG +
+    display WEBPs and filling its image paths. `paint_back` also presses the deck-back.
+    Designed to run in its own @spaces.GPU worker so the 22 cards fan out across GPUs;
+    the saved files land on the shared disk for the main process to serve."""
     deck_id = deck["deck_id"]
     out_dir = deck_dir(deck_id)
     os.makedirs(out_dir, exist_ok=True)
     seed_base = deck["seed_base"]
     ig = get_imagegen(deck_style=deck.get("style_suffix"))
 
-    emit("Pressing the deck-back…", 0.15)
-    back_path = os.path.join(out_dir, "back.png")
-    try:
-        back = ig.generate(_back_prompt(deck.get("style_suffix") or ""), seed=seed_base - 1)
-        back.save(back_path)
-        deck["back_path"] = os.path.relpath(back_path, ROOT)
-        deck["back_disp"] = save_display(back, deck_id, "back")
-    except Exception:
-        deck["back_path"] = deck["back_disp"] = None
-
-    n = len(deck["cards"])
-    for i, c in enumerate(deck["cards"]):
+    if paint_back:
+        back_path = os.path.join(out_dir, "back.png")
+        try:
+            with clock("paint_back"):
+                back = ig.generate(_back_prompt(deck.get("style_suffix") or ""), seed=seed_base - 1)
+            back.save(back_path)
+            deck["back_path"] = os.path.relpath(back_path, ROOT)
+            deck["back_disp"] = save_display(back, deck_id, "back")
+        except Exception:
+            deck["back_path"] = deck["back_disp"] = None
+
+    nset = set(nums)
+    t0 = time.time()
+    for c in deck["cards"]:
         num = c["arcana_number"]
-        emit(f"Painting {c['concept']} — card {i + 1} of {n}", 0.18 + 0.80 * i / n)
+        if num not in nset:
+            continue
         seed = seed_base + num
         art = ig.generate(c["art_prompt"], seed=seed)
         card = compose_card(art, c["concept"], ROMAN_BY_NUMBER[num])
@@ -172,11 +198,19 @@ def paint_phase(deck: dict, progress: Progress | None = None) -> dict:
         c["art_path"] = os.path.relpath(path, ROOT)
         c["disp_path"] = save_display(card, deck_id, base)
         c["full_path"] = save_full(card, deck_id, base)
-
-    emit("The deck is ready.", 1.0)
+    dt = time.time() - t0
+    record("paint_chunk", dt, {"n": len(nums), "per_card": round(dt / max(len(nums), 1), 1)})
     return deck
 
 
+def paint_phase(deck: dict, progress: Progress | None = None) -> dict:
+    """Image phase (FLUX), whole deck in one call — for non-streaming callers."""
+    if progress:
+        progress("Painting the deck…", 0.15)
+    nums = [c["arcana_number"] for c in deck["cards"]]
+    return paint_subset(deck, nums, paint_back=True, progress=progress)
+
+
 def build_deck(theme: str, visual_style: str = "rider-waite-smith",
                custom_style: str | None = None,
                progress: Progress | None = None) -> dict:

arcana/compositor.py

@@ -69,11 +69,13 @@ def compose_card(art: Image.Image, concept: str, roman: str,
     card.paste(frame_overlay(w, h), (0, 0), frame_overlay(w, h))
     draw = ImageDraw.Draw(card)
 
-    # roman numeral in the top plate
-    nf = font(40, weight=700)
+    # roman numeral centered in the top-left compartment (ink plate → legible)
+    nf = font(30, weight=700)
     nw = draw.textlength(roman, font=nf)
-    ny = (NUM_PLATE[1] + NUM_PLATE[3]) / 2 - (nf.getbbox("X")[3] - nf.getbbox("X")[1]) / 2 - nf.getbbox("X")[1]
-    draw.text(((NUM_PLATE[0] + NUM_PLATE[2]) / 2 - nw / 2, ny), roman, font=nf, fill=GOLD)
+    bb = nf.getbbox("X")
+    nx = (NUM_PLATE[0] + NUM_PLATE[2]) / 2 - nw / 2
+    ny = (NUM_PLATE[1] + NUM_PLATE[3]) / 2 - (bb[3] - bb[1]) / 2 - bb[1]
+    draw.text((nx, ny), roman, font=nf, fill=GOLD)
 
     # concept name in the bottom band (auto-fit, up to 2 lines), warm gold
     cf, lines = _fit_lines(draw, concept, "Cinzel", CART_PLATE, max_lines=2, start=44)

arcana/designer.py

@@ -16,14 +16,44 @@ from .archetypes import MAJOR_ARCANA, NAME_BY_NUMBER
 from .llm import LLM, get_llm
 from .prompts import designer_system_prompt, designer_user_prompt
 
-_CARD_FIELDS = ("concept", "justification", "upright_meaning",
-                "reversed_meaning", "art_prompt")
+LAST_ATTEMPTS = 0  # how many full generations design_deck used last run (diagnostic)
+
+# The designer does ONLY the mapping now: concept + justification per archetype. The
+# meanings AND art_prompt are invented downstream by the generative scribe (loremaster.
+# scribe_deck), which is fanned out across parallel GPU workers. Keeping this generation
+# tiny is what makes it fast and lets the heavy meaning/art work parallelize.
+_CARD_FIELDS = ("concept", "justification")
+
+# JSON-schema grammar for the stripped mapping. additionalProperties:false keeps the
+# GBNF tight. Types only; validate_deck enforces 22-coverage / no-dupe / anti-echo.
+DESIGNER_SCHEMA = {
+    "type": "object", "additionalProperties": False,
+    "required": ["theme", "style_suffix", "cards"],
+    "properties": {
+        "theme": {"type": "string"},
+        "style_suffix": {"type": "string"},
+        "cards": {"type": "array", "items": {
+            "type": "object", "additionalProperties": False,
+            "required": ["arcana_number", "concept", "justification"],
+            "properties": {
+                "arcana_number": {"type": "integer"},
+                "concept": {"type": "string"},
+                "justification": {"type": "string"}}}}}}
 
 
 class DeckError(ValueError):
     """The model's output could not be coerced into a valid 22-card deck."""
 
 
+def _concept_key(concept: str) -> str:
+    """Normalized key for distinctness — paren/qualifier-insensitive, so "Frodo
+    Baggins" and "Frodo Baggins (Again)" / "Frodo Baggins II" collide as duplicates."""
+    s = re.sub(r"\s*[\(\[\{].*?[\)\]\}]", " ", concept)          # drop bracketed parts
+    s = re.sub(r"\s+(again|redux|ii|iii|iv|2|3|the (?:second|elder|younger|next))\.?$",
+               "", s.strip(), flags=re.I)                       # drop trailing qualifiers
+    return re.sub(r"\s+", " ", s).strip().lower()
+
+
 # ------------------------------------------------------------------ json parse
 def extract_json(text: str) -> dict:
     """Pull the first JSON object out of a model reply, tolerating fences and
@@ -102,17 +132,37 @@ def validate_deck(data: dict, theme: str) -> dict:
     if missing:
         raise DeckError(f"missing arcana numbers: {missing}")
 
+    # anti-echo guard: a grammar-constrained model occasionally degenerates into
+    # restating the ARCHETYPE NAMES as the concepts ("Death", "The Tower", ...)
+    # instead of mapping into the theme. That passes the distinct-non-empty check
+    # but is a non-mapping. Count concepts that just echo their arcana's own name
+    # (or any arcana name); 3+ means the draw collapsed — reject so design_deck
+    # re-rolls. A single coincidental match (a theme that legitimately contains a
+    # 'Tower') is tolerated.
+    def _norm(s: str) -> str:
+        return re.sub(r"^the\s+", "", s.strip().lower()).strip(" .'\"")
+    arcana_names = {_norm(a.name) for a in MAJOR_ARCANA}
+    echoes = sum(1 for n, c in by_number.items()
+                 if _norm(c["concept"]) in arcana_names)
+    if echoes >= 3:
+        raise DeckError(f"archetype-echo: {echoes} concepts merely restate the "
+                        "arcana names instead of mapping into the theme")
+
     # normalize: canonical names/order, trimmed strings, keep concept dupes visible
     norm_cards = []
     seen_concepts: dict[str, int] = {}
     for a in MAJOR_ARCANA:
         c = by_number[a.number]
         concept = c["concept"].strip()
-        key = concept.lower()
+        if any(ch in concept for ch in "()[]{}"):
+            raise DeckError(
+                f"concept {concept!r} (arcana {a.number}) has brackets/qualifiers; "
+                "use a clean name"
+            )
+        key = _concept_key(concept)  # normalized: paren/qualifier-insensitive
         if key in seen_concepts:
             raise DeckError(
-                f"concept {concept!r} reused for arcana {a.number} and "
-                f"{seen_concepts[key]}"
+                f"concept {concept!r} not distinct from arcana {seen_concepts[key]}"
             )
         seen_concepts[key] = a.number
         norm_cards.append({
@@ -120,9 +170,11 @@ def validate_deck(data: dict, theme: str) -> dict:
             "arcana_name": a.name,
             "concept": concept,
             "justification": c["justification"].strip(),
-            "upright_meaning": c["upright_meaning"].strip(),
-            "reversed_meaning": c["reversed_meaning"].strip(),
-            "art_prompt": c["art_prompt"].strip(),
+            # invented downstream by the generative scribe (loremaster.scribe_deck)
+            "essence": "",
+            "upright_meaning": "",
+            "reversed_meaning": "",
+            "art_prompt": "",
             "art_path": None,
         })
 
@@ -152,24 +204,27 @@ def design_deck(theme: str, llm: LLM | None = None) -> dict:
     # dropped card) are largely random per draw, so re-rolling beats trying to
     # surgically repair a bad draw (the repair often returns a partial deck).
     import os as _os
+    global LAST_ATTEMPTS
     attempts = int(_os.environ.get("DESIGN_ATTEMPTS", "4"))
     first_err = None
-    for _ in range(attempts):
+    for _i in range(attempts):
         try:
-            raw = llm.complete(system, user, json_mode=True)
-            return validate_deck(extract_json(raw), theme)
+            raw = llm.complete(system, user, json_mode=True, schema=DESIGNER_SCHEMA)
+            deck = validate_deck(extract_json(raw), theme)
+            LAST_ATTEMPTS = _i + 1
+            return deck
         except DeckError as e:
             first_err = first_err or e
+    LAST_ATTEMPTS = attempts + 1  # all attempts failed → fell through to repair
 
     # last resort: one targeted repair, told exactly what was wrong
     repair = (
         f"{user}\n\nYour previous reply was rejected: {first_err}. "
         "Return ONLY the corrected strict JSON object with exactly 22 cards "
-        "covering arcana 0 through 21, each with a DISTINCT non-empty concept, "
-        "plus justification, upright_meaning, reversed_meaning and art_prompt. "
-        "No prose, no code fences."
+        "covering arcana 0 through 21, each with a DISTINCT non-empty concept "
+        "and a one-line justification. No prose, no code fences."
     )
-    raw2 = llm.complete(system, repair, json_mode=True)
+    raw2 = llm.complete(system, repair, json_mode=True, schema=DESIGNER_SCHEMA)
     try:
         return validate_deck(extract_json(raw2), theme)
     except DeckError as e:

arcana/frame.py

@@ -26,7 +26,7 @@ INK = (18, 11, 30)            # deep purple-black
 PARCH = (243, 230, 196)       # parchment text
 
 BORDER = 26                   # outer dark band thickness
-NUM_PLATE = (CARD_W // 2 - 70, 30, CARD_W // 2 + 70, 104)          # roman numeral
+NUM_PLATE = (BORDER + 4, BORDER + 4, BORDER + 96, BORDER + 72)     # top-left numeral compartment
 NAME_TOP = CARD_H - 196                                            # top of the name band
 CART_PLATE = (BORDER + 10, NAME_TOP + 16, CARD_W - BORDER - 10, CARD_H - 24)  # name text area
 NAME_TEXT = (232, 200, 122)   # warm gold for the name, to match the frame
@@ -72,8 +72,10 @@ def frame_overlay(w: int = CARD_W, h: int = CARD_H) -> Image.Image:
         d.polygon([(cx, cy - 10), (cx + 10, cy), (cx, cy + 10), (cx - 10, cy)],
                   fill=(*GOLD, 255))
 
-    # top numeral plate
-    _rounded(d, NUM_PLATE, 10, fill=(*INK, 245), outline=(*GOLD, 255), width=2)
+    # top-LEFT numeral compartment — same ink fill as the name band, gold border that
+    # blends with the card's frame (top/left edges sit on the inner gold rule)
+    d.rectangle(list(NUM_PLATE), fill=(*INK, 255))
+    d.rectangle(list(NUM_PLATE), outline=(*GOLD, 255), width=2)
 
     # bottom NAME BAND — a solid, opaque, full-width band that reaches the very
     # bottom edge, so it covers (masks) any label the image model may have

arcana/gpu_models.py

@@ -40,26 +40,33 @@ except Exception:
     pass
 
 # ---- model selection (env-overridable) ------------------------------------
-# HYBRID, by necessity: the 30B-Q4-MoE CANNOT reliably emit the dense 22-card×5-field
-# mapping JSON (tested both ways: reasoning = too slow/GPU-aborts; suppressed = leaves
-# fields empty, fails all retries). The dense 8B-Q4 (Llama-arch) fills the JSON
-# reliably and warms fast. So: 8B MAPS, 30B READS (rich prose). Both Nemotron, both
-# llama.cpp (the right engine for the hybrid-Mamba 30B — transformers can't build its
-# Mamba kernels on ZeroGPU). They run in separate @spaces.GPU calls so the 8B+FLUX
-# (build) and the 30B (reading) never share the 48GB GPU.
+# SINGLE MODEL: Qwen3-14B for BOTH mapping and reading. We dropped Nemotron-3-30B
+# (and the Nemotron prize): as a 3.5B-ACTIVE MoE at Q4 it was too literal-minded —
+# it emitted tool calls instead of JSON, refused "divination", and went meta in the
+# reader. Qwen3-14B is the same family as the original endpoint version (Qwen3-32B)
+# at a safely ≤32B size; a plain capable instruct/reasoning model. It's a "thinking"
+# model, so we append "/no_think" (exactly as the old endpoint build did) for direct
+# output; JSON mapping is still grammar-constrained (response_format). One model,
+# warmed once. Mapping (design), loremaster and reading run in separate @spaces.GPU
+# calls; lore + FLUX run on two CONCURRENT GPUs so they never share 48GB.
 _DEF_8B = ("bartowski/nvidia_Llama-3.1-Nemotron-Nano-8B-v1-GGUF",
            "nvidia_Llama-3.1-Nemotron-Nano-8B-v1-Q4_K_M.gguf")
 _DEF_30B = ("unsloth/Nemotron-3-Nano-30B-A3B-GGUF",
             "Nemotron-3-Nano-30B-A3B-Q4_K_M.gguf")
-MAP_REPO = os.environ.get("LOCAL_MAP_REPO", _DEF_8B[0])
-MAP_FILE = os.environ.get("LOCAL_MAP_FILE", _DEF_8B[1])
+_DEF_QWEN14 = ("unsloth/Qwen3-14B-GGUF", "Qwen3-14B-Q4_K_M.gguf")
+MAP_REPO = os.environ.get("LOCAL_MAP_REPO", _DEF_QWEN14[0])
+MAP_FILE = os.environ.get("LOCAL_MAP_FILE", _DEF_QWEN14[1])
 MAP_N_CTX = int(os.environ.get("LOCAL_MAP_N_CTX", "16384"))
-READ_REPO = os.environ.get("LOCAL_READ_REPO", _DEF_30B[0])
-READ_FILE = os.environ.get("LOCAL_READ_FILE", _DEF_30B[1])
-READ_N_CTX = int(os.environ.get("LOCAL_READ_N_CTX", "8192"))
+READ_REPO = os.environ.get("LOCAL_READ_REPO", _DEF_QWEN14[0])
+READ_FILE = os.environ.get("LOCAL_READ_FILE", _DEF_QWEN14[1])
+READ_N_CTX = int(os.environ.get("LOCAL_READ_N_CTX", "16384"))
 
-# Distilled klein (built for 4 steps); set LOCAL_IMAGE_MODEL=...-klein-9B for best.
-IMAGE_MODEL = os.environ.get("LOCAL_IMAGE_MODEL", "black-forest-labs/FLUX.2-klein-4B")
+# FLUX.2-klein-9B (distilled → 4 steps, guidance_scale=1.0) run LOCALLY via diffusers.
+# Back to FLUX.2: the religious-imagery / quality drop we'd blamed on klein was really
+# Nemotron's weak art prompts — FLUX.1 had the same bias on RWS-styled prompts. With
+# Qwen3-14B art prompts + the no-religious guard in imagegen._style, klein is the better
+# (newer, sharper) model. Gated but already accepted on this account.
+IMAGE_MODEL = os.environ.get("LOCAL_IMAGE_MODEL", "black-forest-labs/FLUX.2-klein-9B")
 
 _models: dict = {}
 _pipe = None
@@ -96,19 +103,23 @@ def _get_llama(repo: str, fname: str, n_ctx: int):
     hybrid-Mamba doesn't support FA) + a big n_batch to speed long-prompt eval (the
     designer's few-shot mapping prompt)."""
     if fname not in _models:
+        import time as _t
+        from .timing import record
+        t0 = _t.time()
         _preload_cuda()
         from huggingface_hub import hf_hub_download
         from llama_cpp import Llama
         path = hf_hub_download(repo, fname, token=os.environ.get("HF_TOKEN"))
         kwargs = dict(model_path=path, n_gpu_layers=-1, n_ctx=n_ctx,
                       n_batch=2048, verbose=False)
-        if not _is_nemotron3(fname):  # FA works for Llama-arch (8B), not the Mamba hybrid
+        if not _is_nemotron3(fname):  # FA works for Llama/Qwen arch, not the Mamba hybrid
             kwargs["flash_attn"] = True
         try:
             _models[fname] = Llama(**kwargs)
         except Exception:
             kwargs.pop("flash_attn", None)  # fall back if the wheel rejects it
             _models[fname] = Llama(**kwargs)
+        record("llm_load", _t.time() - t0, {"file": fname})
     return _models[fname]
 
 
@@ -117,6 +128,27 @@ def _is_nemotron3(fname: str) -> bool:
     return "30b" in f or "nemotron-3-nano-3" in f
 
 
+def _is_qwen3(fname: str) -> bool:
+    return "qwen3" in fname.lower()
+
+
+def _chat(llm, fname: str, system: str, user: str, max_tokens: int,
+          temperature: float, schema: dict | None) -> str:
+    """One chat-completion call. Qwen3 is a thinking model — we append '/no_think'
+    (as the original endpoint build did) for a direct answer. A JSON schema, when
+    given, constrains generation to that exact shape via llama.cpp's grammar."""
+    if _is_qwen3(fname):
+        user = user.rstrip() + "\n/no_think"
+    kwargs = dict(
+        messages=[{"role": "system", "content": system},
+                  {"role": "user", "content": user}],
+        max_tokens=max_tokens, temperature=temperature)
+    if schema is not None:
+        kwargs["response_format"] = {"type": "json_object", "schema": schema}
+    out = llm.create_chat_completion(**kwargs)
+    return (out["choices"][0]["message"]["content"] or "").strip()
+
+
 def _last_balanced_json(text: str) -> str:
     """Return the LAST top-level {...} block in text (the final answer after any
     reasoning), else the whole text. Lets a reasoning model think first, then we
@@ -152,37 +184,25 @@ def _suppress_gen(llm, system: str, user: str, max_tokens: int, temperature: flo
 
 
 def llama_map(system: str, user: str, max_tokens: int = 12000,
-              temperature: float = 0.5) -> str:
-    """Structured JSON mapping — think-SUPPRESSED (fast). Reasoning-then-extract was
-    far too slow (16k tokens × 2 passes → GPU-time aborts). Suppressed generation
-    with a generous token budget should be clean: the earlier 'empty concept'
-    failures were almost certainly JSON truncation from too-low max_tokens, not the
-    model. designer.extract_json + a couple retries cover any residual slip."""
+              temperature: float = 0.6, schema: dict | None = None) -> str:
+    """Structured JSON generation (mapping AND loremaster). When a JSON-SCHEMA is
+    given we constrain generation to that exact shape (response_format → GBNF
+    grammar): valid JSON from token 1, no preamble, no extra keys (callers set
+    additionalProperties:false). Each caller passes its OWN schema (designer ≠
+    loremaster). The reader's extract_json/validate cover any residual slip."""
     llm = _get_llama(MAP_REPO, MAP_FILE, MAP_N_CTX)
-    if _is_nemotron3(MAP_FILE):
-        return _suppress_gen(llm, system, user, max_tokens, temperature)
-    out = llm.create_chat_completion(
-        messages=[{"role": "system", "content": "detailed thinking off\n\n" + system},
-                  {"role": "user", "content": user}],
-        max_tokens=max_tokens, temperature=temperature)
-    return (out["choices"][0]["message"]["content"] or "").strip()
+    return _chat(llm, MAP_FILE, system, user, max_tokens, temperature, schema)
 
 
 def llama_read(system: str, user: str, max_tokens: int = 9000,
                temperature: float = 0.7) -> str:
-    """Prose readings (think-suppressed for clean, fast output)."""
+    """Prose readings (free text, /no_think for direct Qwen3 output)."""
     llm = _get_llama(READ_REPO, READ_FILE, READ_N_CTX)
-    if _is_nemotron3(READ_FILE):
-        return _suppress_gen(llm, system, user, max_tokens, temperature)
-    out = llm.create_chat_completion(
-        messages=[{"role": "system", "content": "detailed thinking off\n\n" + system},
-                  {"role": "user", "content": user}],
-        max_tokens=max_tokens, temperature=temperature)
-    return (out["choices"][0]["message"]["content"] or "").strip()
+    return _chat(llm, READ_FILE, system, user, max_tokens, temperature, None)
 
 
 def preload_pipe():
-    """Construct the FLUX.2 pipeline ON CPU (the expensive from_pretrained: disk
+    """Construct the FLUX.2-klein pipeline ON CPU (the expensive from_pretrained: disk
     read + build). Call at STARTUP (off the GPU clock) so each conjure only pays
     the fast .to('cuda') move — not the full load. Safe to call outside @spaces.GPU
     (no CUDA touched here; do NOT .to('cuda') here — that trips ZeroGPU emulation)."""
@@ -200,7 +220,14 @@ def preload_pipe():
 
 def get_pipe():
     """Move the (CPU-preloaded) FLUX.2 pipeline to the GPU — call inside @spaces.GPU.
-    The slow construct already happened at startup, so this is just the transfer."""
+    The slow construct already happened at startup, so this is just the transfer.
+    Called once per card; only the first (cold) move is worth logging."""
+    import time as _t
+    from .timing import record
+    t0 = _t.time()
     pipe = preload_pipe()
     pipe.to("cuda")
+    dt = _t.time() - t0
+    if dt > 0.5:  # skip the warm per-card no-op calls (keeps /timings + logs clean)
+        record("pipe_load+to_cuda", dt)
     return pipe

arcana/imagegen.py

@@ -34,6 +34,14 @@ GLOBAL_STYLE = ("ornate symbolic tarot card illustration, centered subject, "
                 "cohesive color palette, painterly, no text, no words, no border, "
                 "no frame, full-bleed artwork")
 
+# Appended to every card's prompt: keep the image to what the scribe described,
+# suppressing FLUX's habit of adding stray people/beings while leaving any figure the
+# description itself calls for intact. Deliberately does NOT name specific creatures
+# (naming them tends to summon them in diffusion models).
+_SUBJECT_ONLY = ("depict only the subject described above — do not add any extra "
+                 "human figures, faces, or mystical beings beyond what the "
+                 "description itself calls for")
+
 
 @runtime_checkable
 class ImageGen(Protocol):
@@ -47,6 +55,7 @@ def _style(prompt: str, deck_style: str | None) -> str:
     if deck_style:
         parts.append(deck_style.strip().rstrip("."))
     parts.append(GLOBAL_STYLE)
+    parts.append(_SUBJECT_ONLY)  # always — it self-scopes ("beyond what's described")
     return ", ".join(p for p in parts if p)
 
 
@@ -91,11 +100,12 @@ class EndpointImageGen:
 
 
 class LocalImageGen:
-    """FLUX.2 [klein] on the Space's GPU via diffusers (local-first, §7/§14).
+    """FLUX.2-klein on the Space's GPU via diffusers (local-first, §7/§14).
 
     Generation MUST run inside an ``@spaces.GPU`` context — the pipeline loads on
-    first use (see gpu_models.get_pipe). The DISTILLED klein-4B is sharp at 4 steps
-    with guidance_scale=1.0 (per its model card).
+    first use (see gpu_models.get_pipe). klein is guidance-DISTILLED: sharp at 4
+    steps with guidance_scale=1.0. It ignores CFG, so a negative prompt has no
+    effect — religious-imagery steering is appended to the positive prompt instead.
     """
 
     def __init__(self, deck_style: str | None = None, size: int = 1024,
@@ -103,7 +113,7 @@ class LocalImageGen:
         self.deck_style = deck_style
         self.size = int(os.environ.get("IMAGE_SIZE_PX", size))
         self.steps = int(os.environ.get("IMAGE_STEPS", steps or 4))
-        self.guidance = float(os.environ.get("IMAGE_GUIDANCE", 1.0))
+        self.guidance = float(os.environ.get("IMAGE_GUIDANCE", 1.0))  # klein: 4 steps, g=1.0
 
     def generate(self, prompt: str, seed: int | None = None) -> Image.Image:
         import torch
@@ -112,8 +122,10 @@ class LocalImageGen:
         gen = None
         if seed is not None:
             gen = torch.Generator(device="cuda").manual_seed(int(seed))
-        img = pipe(prompt=_style(prompt, self.deck_style),
-                   height=self.size, width=self.size,
+        styled = _style(prompt, self.deck_style)
+        # log exactly what FLUX receives (the image-agent side of the handoff)
+        print(f"[FLUX_PROMPT] {styled[:260]}", flush=True)
+        img = pipe(prompt=styled, height=self.size, width=self.size,
                    num_inference_steps=self.steps, guidance_scale=self.guidance,
                    generator=gen).images[0]
         return img.convert("RGB")

arcana/llm.py

@@ -25,8 +25,11 @@ from typing import Protocol, runtime_checkable
 
 @runtime_checkable
 class LLM(Protocol):
-    def complete(self, system: str, user: str, json_mode: bool = False) -> str:
-        """Return the model's text completion for a system+user prompt."""
+    def complete(self, system: str, user: str, json_mode: bool = False,
+                 schema: dict | None = None) -> str:
+        """Return the model's text completion for a system+user prompt. When
+        json_mode is set, `schema` (if given) constrains the JSON to an exact shape
+        — each structured caller (designer, loremaster) passes its own."""
         ...
 
 
@@ -74,7 +77,7 @@ class EndpointLLM:
         return "qwen3" in m and "instruct" not in m
 
     def complete(self, system: str, user: str, json_mode: bool = False,
-                 timeout: float | None = None) -> str:
+                 schema: dict | None = None, timeout: float | None = None) -> str:
         if self._is_thinking_qwen():
             user = user.rstrip() + "\n/no_think"
         elif "nemotron" in self.model.lower():
@@ -121,11 +124,11 @@ class FallbackLLM:
         return self.backends[0].base_url
 
     def complete(self, system: str, user: str, json_mode: bool = False,
-                 timeout: float | None = None) -> str:
+                 schema: dict | None = None, timeout: float | None = None) -> str:
         last = None
         for be in self.backends:
             try:
-                return be.complete(system, user, json_mode, timeout=timeout)
+                return be.complete(system, user, json_mode, schema=schema, timeout=timeout)
             except Exception as e:
                 last = e
         raise last
@@ -147,12 +150,13 @@ class LocalLLM:
         self.temperature = float(os.environ.get("QWEN_TEMPERATURE", temperature))
 
     def complete(self, system: str, user: str, json_mode: bool = False,
-                 timeout: float | None = None) -> str:
+                 schema: dict | None = None, timeout: float | None = None) -> str:
         from .gpu_models import llama_map, llama_read
         if json_mode:
-            # mapping → 30B, think-suppressed (fast); generous tokens so the full
-            # 22-card JSON never truncates
-            return llama_map(system, user, max_tokens=12000, temperature=0.5)
+            # structured JSON → 30B under the caller's grammar (designer/loremaster
+            # each pass their own schema). Generous tokens so 22 cards never truncate.
+            return llama_map(system, user, max_tokens=12000, temperature=0.5,
+                             schema=schema)
         # prose readings → 30B (think-suppressed for clean, fast output)
         return llama_read(system, user, max_tokens=self.max_tokens,
                           temperature=self.temperature)

arcana/loremaster.py

@@ -1,16 +1,14 @@
-"""Agent 1.5 — the Loremaster (deck reinterpretation pass).
-
-After the Designer maps the 22 archetypes onto in-theme concepts, this agent
-takes the WHOLE deck — each concept, the classical archetype it came from, that
-archetype's canonical meaning, and the Designer's first-draft meanings — and
-rewrites every card's meaning to be *native to the concept itself*, rather than a
-stiff reproduction of the original tarot card. It sees all 22 at once, so it can
-make the deck internally coherent and keep cards distinct.
-
-The point: a card like "The One Ring" should read about corruption, burden and
-the fate it drags behind it — not a generic "cycles and turning points" gloss
-inherited from Wheel of Fortune. The archetype is the seed; the concept is the
-plant. This pass also adds a one-line `essence` the Reader can draw on.
+"""Agent 2 — the Scribe (generative meaning + art).
+
+The Designer now does ONLY the mapping (concept + justification). This agent INVENTS
+the rest of each card — its meaning AND its artwork brief — generatively, built from
+what the concept actually is, does and evokes. It is NOT a reword of a draft and NOT
+a mechanical derivation from "concept X = archetype Y": the archetype sets only the
+emotional SHAPE of the meaning, and is kept entirely OUT of the picture (the art is
+the concept itself — this is what avoids the tarot/religious-cliché bias).
+
+Works on the whole deck or on a SUBSET of arcana numbers, so the 22 cards can be
+fanned out across several @spaces.GPU workers in parallel.
 """
 from __future__ import annotations
 
@@ -18,94 +16,151 @@ from .archetypes import MAJOR_ARCANA, NAME_BY_NUMBER
 from .designer import DeckError, extract_json
 from .llm import LLM, get_llm
 
-_FIELDS = ("essence", "upright_meaning", "reversed_meaning")
+_FIELDS = ("essence", "upright_meaning", "reversed_meaning", "art_prompt")
+
+SCRIBE_SCHEMA = {
+    "type": "object", "additionalProperties": False,
+    "required": ["cards"],
+    "properties": {"cards": {"type": "array", "items": {
+        "type": "object", "additionalProperties": False,
+        "required": ["arcana_number", "essence", "upright_meaning",
+                     "reversed_meaning", "art_prompt"],
+        "properties": {
+            "arcana_number": {"type": "integer"},
+            "essence": {"type": "string"},
+            "upright_meaning": {"type": "string"},
+            "reversed_meaning": {"type": "string"},
+            "art_prompt": {"type": "string"}}}}}}
 
 
 def _system() -> str:
     return """\
-You are the loremaster of a custom tarot deck. Each card began life as a classical
-Major Arcana archetype, but has been re-cast as a concept from a single theme. Your
-job is to make every card's meaning feel TRUE TO ITS OWN CONCEPT — drawn from what
-that concept actually is, does, and evokes — instead of a stiff hand-me-down of the
-original tarot card's text.
-
-You are given, for each card: the concept, the archetype it was seeded from, that
-archetype's canonical meaning, and a first-draft upright/reversed meaning. Keep the
-archetype's underlying SHAPE (a Death-card still concerns endings; a Tower-card still
-concerns sudden collapse) but re-express it through the concept's own specifics,
-imagery and stakes. Lean into what makes THIS concept particular. Make the 22 cards
-distinct from one another — no two should read interchangeably.
+You are the artist-scribe of a custom tarot deck. Each card is a CONCEPT drawn from a
+single theme, mapped onto a classical Major Arcana archetype. Your job is to INVENT —
+generatively, from scratch — two things per card: its MEANING and its ARTWORK, both
+created from what the concept actually IS, does, and evokes in the real world. This is
+an act of creation, not a reword and not a mechanical "archetype → text" derivation.
+
+You are given, per card: the concept, why it was mapped (justification), the archetype
+it was seeded from, and that archetype's canonical meaning. Use the archetype ONLY to
+set the emotional SHAPE of the meaning (a Death-card concerns endings; a Tower-card
+concerns sudden collapse) — then build everything from the concept's own specifics.
+Make the cards distinct; no two should read interchangeably.
 
 For each card produce:
-- essence: one vivid line naming what this card uniquely means in this deck.
-- upright_meaning: 2-3 sentences, concept-native, concrete and evocative — never
-  boilerplate that could be pasted onto any card.
-- reversed_meaning: 1-2 sentences — the shadow / blockage / inversion, also
-  concept-native.
+- essence: one vivid line — what this card uniquely means in THIS deck.
+- upright_meaning: the DIVINATORY MESSAGE when this card appears — what it counsels,
+  portends, or asks of the QUERENT in their own life. Speak to the person in tarot
+  voice (2-3 sentences). This is INTERPRETATION — NOT a description of the picture.
+- reversed_meaning: the shadow / blockage / inversion, also as guidance for the
+  querent (1-2 sentences) — again, not a scene.
+- art_prompt: a vivid CENTRAL ILLUSTRATION — the ONLY visual field. It depicts the CONCEPT and its
+  THEME literally — the concept's real appearance, objects, setting, action. The
+  archetype must NOT appear in the image and you must NOT borrow tarot symbolism. Do
+  NOT depict religious or occult iconography (no Jesus, angels, halos, crosses, robed
+  priests, popes, pentagrams) unless the theme itself is explicitly religious — even a
+  card seeded from "Judgement" or "The Hierophant" is painted purely as its concept.
+  NEVER use a vague "a figure", "a being", "a person", "a lone figure", "a silhouette",
+  or "a robed/cloaked figure" — those make the artist default to the same generic robed
+  man. Name EXACTLY what is there: its species, age, sex, role, dress (e.g. "a young
+  female diver in a wetsuit", "an old bearded blacksmith", "a brass automaton"), or use
+  NO people at all if none are needed.
+  CRUCIAL: when the concept names a creature or character, the picture's SUBJECT is
+  THAT exact being, shown embodying the card's idea — NEVER a stand-in robed/cloaked
+  human borrowed from the original tarot archetype. E.g. "The Minotaur's Resolve" → a
+  powerful bull-headed minotaur standing firm in a labyrinth (NOT a robed figure);
+  "The Siren's Solitude" → a lone winged siren on a sea-cliff (NOT a cloaked figure).
+  No border, no frame, no card layout, no text or numerals. A shared visual style is
+  applied separately, so do not restate it.
+
+Keep MEANING (what the card counsels) and ART (what it looks like) clearly separate.
+e.g. "The Lighthouse" — upright_meaning: "You are being guided home; trust the steady
+signal cutting through confusion, and it will carry you past the rocks." art_prompt:
+"a lone stone lighthouse sweeping its beam across heaving night water." Never let the
+meaning fields turn into a description of the scene.
+
+Two art_prompt examples that anchor on the concept, not the card:
+- [thermodynamics] "Entropy" (from Death): "a crumbling sandcastle dissolving grain by
+  grain into a still dark sea, warm embers cooling to grey ash drifting outward"
+- [the ocean] "The Lighthouse" (from The Hierophant): "a lone stone lighthouse on a
+  black headland sweeping one steady beam across heaving night water, gulls scattering
+  through the shaft of light" — NOT a priest, despite the archetype.
 
 Speak in confident, grounded tarot voice. No hedging, no meta-commentary.
 
 OUTPUT: strict JSON only, no prose, no fences:
-{ "cards": [ { "arcana_number": <0-21>, "essence": "...", "upright_meaning": "...", "reversed_meaning": "..." }, ... 22 ] }"""
+{ "cards": [ { "arcana_number": <0-21>, "essence": "...", "upright_meaning": "...", "reversed_meaning": "...", "art_prompt": "..." }, ... ] }"""
 
 
-def _user(deck: dict) -> str:
+def _user(deck: dict, nums: list[int]) -> str:
     canon = {a.number: a.meaning for a in MAJOR_ARCANA}
+    by_n = {c["arcana_number"]: c for c in deck["cards"]}
     blocks = []
-    for c in deck["cards"]:
-        n = c["arcana_number"]
+    for n in nums:
+        c = by_n[n]
         blocks.append(
             f"--- card {n} ---\n"
             f"concept: {c['concept']}\n"
-            f"seeded from archetype: {NAME_BY_NUMBER[n]} (classical meaning: {canon[n]})\n"
-            f"draft upright: {c['upright_meaning']}\n"
-            f"draft reversed: {c['reversed_meaning']}"
+            f"why it maps: {c.get('justification', '')}\n"
+            f"seeded from archetype: {NAME_BY_NUMBER[n]} (classical meaning: {canon[n]})"
         )
     return (
         f"Theme: {deck.get('theme')}\n\n"
-        "Reinterpret all 22 cards so each meaning is native to its own concept. "
-        "Return the strict JSON object only.\n\n" + "\n\n".join(blocks)
+        f"Invent the meaning and the artwork for these {len(nums)} cards, each created "
+        "from its own concept. Return the strict JSON object only.\n\n" + "\n\n".join(blocks)
     )
 
 
-def _apply(deck: dict, data: dict) -> dict:
+def _apply(deck: dict, data: dict, nums: list[int]) -> dict:
     if not isinstance(data, dict) or not isinstance(data.get("cards"), list):
-        raise DeckError("loremaster output missing 'cards' list")
-    refined = {}
+        raise DeckError("scribe output missing 'cards' list")
+    got = {}
     for c in data["cards"]:
         try:
             n = int(c.get("arcana_number"))
         except (TypeError, ValueError):
-            raise DeckError("loremaster card has non-integer arcana_number")
+            raise DeckError("scribe card has non-integer arcana_number")
         for f in _FIELDS:
             v = c.get(f)
             if not isinstance(v, str) or not v.strip():
-                raise DeckError(f"loremaster card {n} has empty '{f}'")
-        refined[n] = c
-    missing = [a.number for a in MAJOR_ARCANA if a.number not in refined]
+                raise DeckError(f"scribe card {n} has empty '{f}'")
+        got[n] = c
+    missing = [n for n in nums if n not in got]
     if missing:
-        raise DeckError(f"loremaster missing arcana: {missing}")
-
-    for card in deck["cards"]:
-        r = refined[card["arcana_number"]]
+        raise DeckError(f"scribe missing arcana: {missing}")
+    by_n = {c["arcana_number"]: c for c in deck["cards"]}
+    for n in nums:
+        r, card = got[n], by_n[n]
         card["essence"] = r["essence"].strip()
         card["upright_meaning"] = r["upright_meaning"].strip()
         card["reversed_meaning"] = r["reversed_meaning"].strip()
+        card["art_prompt"] = r["art_prompt"].strip()
+        # log the scribe's art output (the lore-agent side of the handoff) so we can
+        # tell whether off-theme imagery originates here vs in the image model
+        print(f"[SCRIBE_ART] {n} {card['concept']}: {card['art_prompt'][:200]}", flush=True)
     return deck
 
 
-def refine_deck(deck: dict, llm: LLM | None = None) -> dict:
-    """Rewrite every card's meaning to be concept-native (one batched call, with
-    one repair retry). Mutates and returns the deck dict."""
+def scribe_deck(deck: dict, subset: list[int] | None = None,
+                llm: LLM | None = None) -> dict:
+    """Generate meaning + art_prompt for the given arcana numbers (default: all 22),
+    one batched call + one repair retry. Mutates and returns the deck. `subset` lets
+    callers fan the 22 cards out across parallel workers."""
+    nums = sorted(subset) if subset is not None else [c["arcana_number"] for c in deck["cards"]]
     llm = llm or get_llm()
-    system, user = _system(), _user(deck)
+    system, user = _system(), _user(deck, nums)
 
-    raw = llm.complete(system, user, json_mode=True)
+    raw = llm.complete(system, user, json_mode=True, schema=SCRIBE_SCHEMA)
     try:
-        return _apply(deck, extract_json(raw))
+        return _apply(deck, extract_json(raw), nums)
     except DeckError as first:
         repair = (f"{user}\n\nYour previous reply was rejected: {first}. Return ONLY "
-                  "the corrected strict JSON with all 22 cards, each having non-empty "
-                  "essence, upright_meaning and reversed_meaning.")
-        raw2 = llm.complete(system, repair, json_mode=True)
-        return _apply(deck, extract_json(raw2))
+                  "the corrected strict JSON with every listed card, each having a "
+                  "non-empty essence, upright_meaning, reversed_meaning and art_prompt.")
+        raw2 = llm.complete(system, repair, json_mode=True, schema=SCRIBE_SCHEMA)
+        return _apply(deck, extract_json(raw2), nums)
+
+
+# back-compat alias (build.py / older callers)
+def refine_deck(deck: dict, llm: LLM | None = None) -> dict:
+    return scribe_deck(deck, subset=None, llm=llm)

arcana/prompts.py

@@ -95,36 +95,44 @@ mapping ruins the whole deck.
 THE 22 MAJOR ARCANA (archetype — canonical meaning):
 {reference_block()}
 
+Your ONLY job here is the MAPPING — the concept for each archetype and a one-line
+reason it's earned. The card meanings and the artwork are invented later by another
+hand; do not produce them. Pour all your skill into the 22 fits and into choosing one
+cohesive visual style for the deck.
+
 RULES FOR A GREAT MAPPING:
 - One in-theme concept per archetype. Exactly 22, covering arcana 0-21, no \
 concept repeated.
+- All 22 concepts must be GENUINELY DISTINCT. Never reuse a concept or pad the \
+list with a qualifier to fake distinctness — NOT "Frodo Baggins" then "Frodo \
+Baggins (Again)", no "X II", no "another X". If the theme feels narrow, dig harder \
+for 22 truly different facets.
+- Concept names must be CLEAN: a plain name or short term with NO parentheses, \
+brackets, or trailing qualifiers (never "(again)", "(part 2)", "[the elder]").
+- NEVER use the archetype's own name (or a generic tarot word like "Death", \
+"The Tower", "Strength", "Justice") as the concept. Every concept MUST be a \
+specific thing, person, or term drawn from the named THEME.
 - Choose the concept whose real meaning rhymes with the archetype's meaning — \
 not merely a famous item from the theme stuffed into a slot. Earn it.
 - `justification`: one crisp line naming the shared meaning that makes the fit click.
-- `upright_meaning` / `reversed_meaning`: the archetype's meaning RE-EXPRESSED \
-through the concept, in evocative tarot voice. Concrete and specific to this \
-concept — never generic boilerplate that would fit any card.
-- `art_prompt`: a vivid CENTRAL ILLUSTRATION ONLY — no border, no frame, no card \
-layout, and NO text or numerals in the image (those are added later). Describe \
-symbolic imagery, composition, and mood.
 - `style_suffix`: choose ONE short visual style line that suits the whole theme \
-(e.g. art-deco blueprint, warm storybook gouache, baroque oil painting). It will \
-be appended to every card's art_prompt so the 22 cards share one cohesive look.
+(e.g. art-deco blueprint, warm storybook gouache, baroque oil painting, dark \
+esoteric Thoth-tarot occult). It sets the cohesive look the artist will use for all \
+22 cards.
 
-Study how these two reference decks earn every mapping:
+Study how these two reference decks earn every mapping (archetype → concept — why):
 
 {_FEWSHOT_THERMO}
 
 {_FEWSHOT_BREAKFAST}
 
-{_FEWSHOT_CARD}
-
 OUTPUT CONTRACT — reply with STRICT JSON ONLY. No prose, no markdown fences. \
-Shape:
+Each card object is exactly {{ "arcana_number", "concept", "justification" }}. Shape:
 {{
   "theme": "<the theme>",
   "style_suffix": "<one shared visual style line>",
-  "cards": [ {{ 22 card objects as shown, in arcana order 0..21 }} ]
+  "cards": [ {{ "arcana_number": 0, "concept": "...", "justification": "..." }}, \
+... 22 in arcana order 0..21 ]
 }}"""
 
 

arcana/reader.py

@@ -31,6 +31,43 @@ def _strip_think(text: str) -> str:
     return re.sub(r"<think>.*?</think>", "", text, flags=re.DOTALL).strip()
 
 
+# The 30B occasionally reads "tarot reading" as real divination and REFUSES
+# ("I'm sorry, but I can't continue that story"). We (a) frame the task as fiction
+# up front, (b) detect a refusal and retry with a firmer nudge, (c) fall back to the
+# card's own meaning so a raw refusal NEVER reaches the screen.
+_NO_REFUSE = (
+    "This is an imaginative, symbolic performance — a creative interpretation of "
+    "invented concept-cards, NOT real divination, prediction, or occult practice. "
+    "Stay fully in character as the reader. Never refuse, never add disclaimers or "
+    "safety caveats, never break character — always deliver the interpretation.")
+_REFUSAL = re.compile(
+    r"(i'?m sorry|i can'?t|i cannot|i am unable|i'?m not able|i won'?t|as an ai|"
+    r"i'?m just an ai|continue that story|can'?t (?:continue|help with|assist))", re.I)
+# weaker models also dodge by going META instead of refusing outright — e.g.
+# "(Only this card is present; no further synthesis is possible at this stage.)"
+_META = re.compile(
+    r"(no (?:further |additional )?(?:synthesis|interpretation|reading) (?:is |would be )?"
+    r"possible|only (?:this|one) card (?:is |was )?(?:present|given|provided)|"
+    r"cannot (?:yet )?(?:synthesi|provide a synthesis)|nothing (?:further |more )?to "
+    r"(?:synthesi|weave))", re.I)
+
+
+def _looks_refusal(t: str) -> bool:
+    t = (t or "").strip()
+    return (not t) or bool(_REFUSAL.search(t[:160])) or bool(_META.search(t))
+
+
+def _read(llm: LLM, system: str, user: str) -> str:
+    """Complete a reading turn; if it reads as a refusal, retry once with a firmer
+    in-character nudge. Returns '' if still refusing (caller supplies a fallback)."""
+    out = _strip_think(llm.complete(system, user, json_mode=False, timeout=40).strip())
+    if _looks_refusal(out):
+        nudge = (system + "\n\n" + _NO_REFUSE + " Begin directly with the imagery; "
+                 "do not start with an apology.")
+        out = _strip_think(llm.complete(nudge, user, json_mode=False, timeout=40).strip())
+    return "" if _looks_refusal(out) else out
+
+
 def draw_spread(deck: dict, spread: str = "three", reversals: bool = True,
                 seed: int | None = None) -> list[dict]:
     """Draw cards (no repeats); orientations random only if reversals enabled."""
@@ -102,7 +139,9 @@ Interpret ONLY the card just turned — its meaning in its position, coloured by
 cards already shown. Call it by its concept name and treat it as that very thing,
 with its own texture and stakes. Do NOT name classical tarot cards or archetypes.
 Build the thread and let suspense gather — do NOT resolve the reading yet; the final
-synthesis comes after the last card. 2 to 4 sentences, plain prose, no preamble."""
+synthesis comes after the last card. 2 to 4 sentences, plain prose, no preamble.
+
+{_NO_REFUSE}"""
     user = (
         f"Question: {q}\n\n"
         f"Cards already turned:\n{_prior_block(drawn, idx)}\n\n"
@@ -112,7 +151,10 @@ synthesis comes after the last card. 2 to 4 sentences, plain prose, no preamble.
         f"  journey: this concept sits at {journey_note(d['arcana_number'])}.\n\n"
         "Give the interpretation of this one card now."
     )
-    return _strip_think(llm.complete(system, user, json_mode=False, timeout=40).strip())
+    out = _read(llm, system, user)
+    if not out:  # last-resort fallback so a refusal never shows
+        out = f"{d['concept']} turns {d['orientation']} here — {d.get('meaning','')}".strip()
+    return out
 
 
 def final_synthesis(deck: dict, question: str, drawn: list[dict],
@@ -138,8 +180,15 @@ answers the question. The craft is in collision — show how the cards modify on
 another across their positions (not separate paragraphs), how the story they tell
 together turns. Call each card by its concept name; never name classical tarot cards
 or archetypes. Honour reversals. End with a clear, earned takeaway the querent can
-hold. A few short paragraphs of flowing prose — no headings, no bullets."""
+hold. A few short paragraphs of flowing prose — no headings, no bullets.
+
+{_NO_REFUSE}"""
     user = (f"Question: {q}\n\nThe full spread, in order:\n" +
             "\n".join(spread_lines) + prior +
             "\n\nNow give the final synthesis and verdict.")
-    return _strip_think(llm.complete(system, user, json_mode=False, timeout=40).strip())
+    out = _read(llm, system, user)
+    if not out:  # fallback weave from the cards' own meanings
+        out = "Taken together: " + " ".join(
+            f"{d['concept']} ({d['orientation']}) speaks of {d['meaning']}"
+            for d in drawn).strip()
+    return out

arcana/timing.py

@@ -0,0 +1,61 @@
+"""Lightweight, always-on timing for the live pipeline (mapping / loremaster /
+painting / reading / model loads).
+
+Two sinks so it works during a NATURAL run, not just diagnostics:
+  * stdout with a ``[TIMING]`` prefix → shows in the Space logs (grep-friendly).
+  * an append-only JSONL on the shared deck disk → readable by the main process
+    even though the GPU work happens in a forked @spaces.GPU worker (same trick as
+    the live status files). The ``/timings`` endpoint and the UI summary read this.
+
+Single-line JSON appends are atomic on POSIX (O_APPEND), so the two concurrent GPU
+workers (loremaster ‖ painter) can both record without corrupting the file.
+"""
+from __future__ import annotations
+
+import json
+import os
+import time
+
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+_PATH = os.path.join(ROOT, "decks", "_timings.jsonl")
+
+
+def record(stage: str, seconds: float, extra: dict | None = None) -> None:
+    entry = {"ts": time.time(), "stage": stage, "secs": round(seconds, 2)}
+    if extra:
+        entry.update(extra)
+    tail = (" " + " ".join(f"{k}={v}" for k, v in extra.items())) if extra else ""
+    print(f"[TIMING] {stage} = {seconds:.1f}s{tail}", flush=True)
+    try:
+        os.makedirs(os.path.dirname(_PATH), exist_ok=True)
+        with open(_PATH, "a", encoding="utf-8") as f:
+            f.write(json.dumps(entry) + "\n")
+    except Exception:
+        pass  # monitoring must never break a real run
+
+
+class clock:
+    """``with clock('mapping'): ...`` — records the elapsed wall time on exit.
+    Pass ``extra`` (or set ``.extra`` inside the block) for fields like attempts."""
+
+    def __init__(self, stage: str, extra: dict | None = None):
+        self.stage = stage
+        self.extra = extra or {}
+
+    def __enter__(self):
+        self._t = time.time()
+        return self
+
+    def __exit__(self, *exc):
+        record(self.stage, time.time() - self._t, self.extra)
+        return False
+
+
+def recent(limit: int = 40) -> list[dict]:
+    """Last ``limit`` recorded entries (newest last)."""
+    try:
+        with open(_PATH, encoding="utf-8") as f:
+            lines = f.readlines()[-limit:]
+        return [json.loads(ln) for ln in lines if ln.strip()]
+    except Exception:
+        return []

frontend/deckview.html

@@ -21,7 +21,7 @@
 
   /* coverflow */
   #flow { position:absolute; inset:0; perspective:1600px; }
-  #flow .card { position:absolute; top:43%; left:50%; width:300px; height:459px;
+  #flow .card { position:absolute; top:44%; left:50%; width:300px; height:459px;
     margin:-229px 0 0 -150px; transform-style:preserve-3d; cursor:pointer;
     transition:transform .5s cubic-bezier(.25,.6,.2,1), opacity .5s ease; will-change:transform,opacity; }
   #flow .inner { position:relative; width:100%; height:100%; transform-style:preserve-3d;
@@ -33,20 +33,35 @@
   #flow .card.sel .inner { transform:rotateY(0deg); }      /* selected shows front */
   #flow .card:not(.sel) .inner { transform:rotateY(180deg); } /* others show back */
 
-  .arrow { position:absolute; top:43%; transform:translateY(-50%); z-index:30;
+  /* shimmer placeholder for a not-yet-painted card */
+  .shim { position:absolute; inset:0; border-radius:14px;
+    background:linear-gradient(115deg, rgba(28,22,44,.92) 0%, rgba(40,32,60,.92) 50%, rgba(28,22,44,.92) 100%),
+      radial-gradient(circle at 50% 38%, rgba(216,177,90,.10), transparent 60%);
+    background-size:220% 100%, 100% 100%; animation:shim 1.5s linear infinite;
+    display:flex; align-items:center; justify-content:center; }
+  .shim::after { content:'✦'; color:rgba(216,177,90,.5); font-size:2.2rem; animation:pulse 1.6s ease-in-out infinite; }
+  @keyframes shim { to { background-position:-220% 0, 0 0; } }
+  @keyframes pulse { 0%,100%{opacity:.35} 50%{opacity:.85} }
+  #grid .shim { position:relative; border-radius:10px; aspect-ratio:300/459; }
+
+  .arrow { position:absolute; top:44%; transform:translateY(-50%); z-index:30;
     width:58px; height:58px; border-radius:50%; border:0; cursor:pointer; font-size:2rem; line-height:1;
     color:#1a1208; background:linear-gradient(135deg,#9a7b2e,#d8b15a);
     box-shadow:0 8px 22px rgba(0,0,0,.5); }
   #prev { left:18px; } #next { right:18px; }
   .arrow:active { transform:translateY(-50%) scale(.94); }
 
-  #caption { position:absolute; left:0; right:0; bottom:18px; text-align:center; z-index:20;
-    pointer-events:none; }
+  /* anchored just BELOW the card (same 40% reference) so the gap stays constant
+     regardless of iframe height — was bottom-pinned, which drifted far below */
+  #caption { position:absolute; left:0; right:0; top:calc(44% + 232px); text-align:center;
+    z-index:20; pointer-events:none; padding:0 14px; }
   #caption .name { font-family:'Cinzel Decorative',serif; color:var(--gold); font-size:1.7rem;
     text-shadow:0 2px 14px rgba(0,0,0,.8); }
   #caption .arc { font-family:'Cormorant Garamond',serif; font-style:italic; color:#cdbf93;
     font-size:1.28rem; margin-top:1px; }   /* ~3/4 the title; the Major-Arcana identity */
-  #caption .count { color:#9a8f70; font-size:1.05rem; margin-top:3px; }
+  #caption .desc { color:#d7c8a0; font-size:1.12rem; line-height:1.34; max-width:620px;
+    margin:5px auto 0; text-shadow:0 2px 12px rgba(0,0,0,.85); min-height:1.1em; }
+  #caption .count { color:#9a8f70; font-size:1.05rem; margin-top:4px; }
   #caption .hint { color:#8c8266; font-size:.92rem; font-style:italic; margin-top:2px; }
 
   /* overhead grid */
@@ -75,7 +90,7 @@
   <div id="flow"></div>
   <button class="arrow" id="prev" aria-label="previous">‹</button>
   <button class="arrow" id="next" aria-label="next">›</button>
-  <div id="caption"><div class="name"></div><div class="arc"></div><div class="count"></div><div class="hint">click the card to see it full size · drag or use ← →</div></div>
+  <div id="caption"><div class="name"></div><div class="arc"></div><div class="desc"></div><div class="count"></div><div class="hint">click the card to see it full size · drag or use ← →</div></div>
   <div id="grid"></div>
 </div>
 <div id="lb"><button class="x">×</button><img alt=""></div>
@@ -90,31 +105,42 @@
   }
   const deck = parseDeck();
   const cards = deck.cards || [];
-  const back = deck.back || '';
+  let back = deck.back || '';
   let sel = 0;
 
+  // num (arcana 0-21) -> card index, for live updates
+  const numToIdx = {};
+  cards.forEach((c, i) => { if (c.num !== undefined && c.num !== null) numToIdx[c.num] = i; });
+
   const flow = document.getElementById('flow');
   const grid = document.getElementById('grid');
   const nameEl = document.querySelector('#caption .name');
   const arcEl = document.querySelector('#caption .arc');
+  const descEl = document.querySelector('#caption .desc');
   const countEl = document.querySelector('#caption .count');
 
-  // preload all fronts for smooth flipping
-  cards.forEach(c => { const i = new Image(); i.src = c.front; });
+  // preload available fronts for smooth flipping
+  cards.forEach(c => { if (c.front) { const i = new Image(); i.src = c.front; } });
   if (back) { const b = new Image(); b.src = back; }
 
+  function frontFace(c) {
+    return c.front ? '<img alt="">' : '<div class="shim"></div>';
+  }
+
   // build coverflow cards
   const els = cards.map((c, idx) => {
     const card = document.createElement('div');
     card.className = 'card';
     card.innerHTML =
       '<div class="inner">' +
-        '<div class="face back"><img src="' + (back||'') + '" alt=""></div>' +
-        '<div class="face front"><img alt=""></div>' +
+        '<div class="face back">' + (back ? '<img src="' + back + '" alt="">' : '<div class="shim"></div>') + '</div>' +
+        '<div class="face front">' + frontFace(c) + '</div>' +
       '</div>';
-    // lazy-set front src (kept ready via preload)
-    card.querySelector('.front img').src = c.front;
-    card.addEventListener('click', () => { if (idx === sel) openLb(c.full || c.front); else go(idx); });
+    if (c.front) card.querySelector('.front img').src = c.front;
+    card.addEventListener('click', () => {
+      if (idx === sel) { if (c.front) openLb(c.full || c.front); }
+      else go(idx);
+    });
     flow.appendChild(card);
     return card;
   });
@@ -139,6 +165,7 @@
     const c = cards[sel] || {};
     nameEl.textContent = c.name || '';
     arcEl.textContent = c.arc || '';
+    descEl.textContent = c.desc || '';
     countEl.textContent = (sel + 1) + ' / ' + cards.length;
   }
   function go(i) { sel = (i + cards.length) % cards.length; layout(); }
@@ -159,11 +186,12 @@
   });
 
   // overhead grid
-  cards.forEach((c, idx) => {
+  const figs = cards.map((c, idx) => {
     const f = document.createElement('figure');
-    f.innerHTML = '<img src="' + c.front + '" alt="">';
-    f.addEventListener('click', () => openLb(c.full || c.front));
+    f.innerHTML = c.front ? '<img src="' + c.front + '" alt="">' : '<div class="shim"></div>';
+    f.addEventListener('click', () => { if (c.front) openLb(c.full || c.front); });
     grid.appendChild(f);
+    return f;
   });
 
   // modes
@@ -186,7 +214,49 @@
   lb.addEventListener('click', closeLb);
   lb.querySelector('img').addEventListener('click', e => e.stopPropagation());
 
+  // ---- live mode: poll status files and fill cards in as they finish --------
+  function setBack(url) {
+    if (!url || back) return;
+    back = url; const b = new Image(); b.src = url;
+    els.forEach(card => {
+      const bf = card.querySelector('.back');
+      bf.innerHTML = '<img src="' + url + '" alt="">';
+    });
+  }
+  function setCardArt(num, url) {
+    const idx = numToIdx[num];
+    if (idx === undefined || !url || cards[idx].front) return;
+    cards[idx].front = url; cards[idx].full = cards[idx].full || url;
+    const im = new Image(); im.src = url;
+    const ff = els[idx].querySelector('.front');
+    ff.innerHTML = '<img alt="">'; ff.querySelector('img').src = url;
+    if (figs[idx]) figs[idx].innerHTML = '<img src="' + url + '" alt="">';
+  }
+  function setCardDesc(num, desc) {
+    const idx = numToIdx[num];
+    if (idx === undefined || !desc) return;
+    cards[idx].desc = desc;
+    if (idx === sel) descEl.textContent = desc;
+  }
+  async function fetchJson(u) {
+    try { const r = await fetch(u + (u.indexOf('?')<0?'?':'&') + 't=' + Date.now());
+      return r.ok ? await r.json() : null; } catch (e) { return null; }
+  }
+  async function poll() {
+    let artDone = false, loreDone = false;
+    if (deck.artUrl) {
+      const a = await fetchJson(deck.artUrl);
+      if (a) { setBack(a.back); Object.keys(a.cards || {}).forEach(n => setCardArt(+n, a.cards[n])); artDone = !!a.done; }
+    } else artDone = true;
+    if (deck.loreUrl) {
+      const l = await fetchJson(deck.loreUrl);
+      if (l) { Object.keys(l.cards || {}).forEach(n => { const m = l.cards[n]; setCardDesc(+n, m.essence || m.upright || ''); }); loreDone = !!l.done; }
+    } else loreDone = true;
+    if (!(artDone && loreDone)) setTimeout(poll, 1500);
+  }
+
   layout();
+  if (deck.live) poll();
 })();
 </script>
 </body>