Upload 2 files

README.md

@@ -1,5 +1,5 @@
 ---
-title: MiniMax-H3 · reference · Shared lora library + CivitAI + scene continuation + identity lock
+title: MiniMax-H3 · reference · One button, photo to video
 emoji: 🎭
 colorFrom: pink
 colorTo: purple
@@ -7,7 +7,7 @@ sdk: gradio
 sdk_version: 6.20.0
 app_file: app.py
 pinned: true
-short_description: Video + soundtrack, shared lora library, structured prompts
+short_description: One button — it writes the prompt and picks the loras
 suggested_hardware: zero-a10g
 tags:
   - not-for-all-audiences
@@ -20,10 +20,36 @@ tags:
   - zerogpu
 ---
 
-# MiniMax-H3 — omni-references, unquantized, split across two Spaces
+# MiniMax-H3 — one button, or every dial
 
-Joint video **and** soundtrack out of a single denoising pass, conditioned on an ordered list of image, video and
-audio references, at **bfloat16 with no quantization anywhere**.
+**Picture in, a few words, one press.** The description is written from your first reference picture, wrapped in the
+labelled sections H3 was actually trained on, and the shared library is searched for loras that match it. Everything
+this Space can do is still here — one tick at the top swaps the whole page over to it.
+
+Underneath: joint video **and** soundtrack out of a single denoising pass, conditioned on an ordered list of image,
+video and audio references, at **bfloat16 with no quantization anywhere**.
+
+## 🟢 Simple — the button does the lot
+
+One press, and:
+
+* **The description is written from your first reference picture.** Not from your words alone — the picture is shown
+  to a chat Space of your choosing, so what comes back describes the subject and the setting actually in front of it.
+* **The structure goes on around it.** The prose is wrapped in the labelled sections below, the part MiniMax call
+  *critical to the quality of the final output* — so the one thing that most changes the result is no longer
+  something you have to remember to press.
+* **The loras are chosen.** The shared library is searched, the handful that match your words are shortlisted, and
+  the two that fit best go into the slots at their own strengths.
+* **The trigger words go into the prompt.** An adapter whose token is missing does nothing at all, and that is the
+  commonest reason one seems to be ignored.
+
+Whatever it picked is listed underneath with the rest of the shortlist. **Tick a different one and it swaps** — the
+slots refill, the old trigger words come out and the new ones go in. Two at a time is the limit, because stacking
+more only means each one shows less.
+
+Leave the Space box empty and the button still builds the structured prompt out of your own words.
+
+## 🔧 Everything — what this fork adds
 
 This Space is the denoising half of the `ref2va` task: the 61.73 GiB `transformer_ref` partition and the two
 autoencoders. The 62.14 GiB Qwen3-VL conditioner runs in
@@ -31,7 +57,6 @@ autoencoders. The 62.14 GiB Qwen3-VL conditioner runs in
 the gradio API for every request — the same conditioner Space, and the same resident weights, that the keyframe half
 [`minimax-h3`](https://huggingface.co/spaces/multimodalart/minimax-h3) uses.
 
-## What this fork adds
 
 **A structured prompt builder.** H3 was trained on the output of H3-Context-IR, a preprocessor that rewrites a plain
 request into labelled sections, and MiniMax's own model card calls that structure *critical to the quality of the

app.py

@@ -2525,9 +2525,340 @@ visit, so a saved path would come back as a dead file.
 
 # gradio 6.0 takes `theme` and `css` on launch(), not here - passing them to the constructor
 # only earns a warning and the styling is dropped.
+# ---------------------------------------------------------------------------
+# Simple mode: a borrowed Space writes the prompt, the library is searched for loras
+# ---------------------------------------------------------------------------
+
+# Set the Space variable EXPANDER_SPACE to point this somewhere else.
+REMOTE_SPACE = os.environ.get("EXPANDER_SPACE",
+                              "amisima/Qwen3.8-27B-Uncensored-Demo").strip()
+_REMOTE_CLIENTS = {}
+
+
+def _remote_reply_text(result):
+    """Pull the assistant's words out of whatever shape the Space hands back - a string,
+    a message dict, a list of them, or history pairs. Thinking bubbles carry a metadata
+    title and are dropped, the same way the Space itself drops them."""
+    if result is None:
+        return ""
+    if isinstance(result, str):
+        return result.strip()
+    if isinstance(result, dict):
+        if (result.get("metadata") or {}).get("title"):
+            return ""
+        return _remote_reply_text(result.get("content", result.get("text", "")))
+    if isinstance(result, (list, tuple)):
+        parts = [part for part in (_remote_reply_text(item) for item in result) if part]
+        return "\n".join(parts[-2:]) if len(parts) > 2 else "\n".join(parts)
+    return str(result).strip()
+
+
+def _make_remote_client(space_id):
+    """`Client(src, hf_token=...)` is what the documentation says and what the installed
+    client may no longer accept - the argument has been spelled three ways across
+    versions. Ask the signature which name it wants, fall back to sending the token as a
+    header, and connect anonymously rather than not at all."""
+    import inspect
+
+    from gradio_client import Client
+
+    token = os.environ.get("HF_TOKEN") or None
+    if not token:
+        return Client(space_id)
+    try:
+        accepted = list(inspect.signature(Client.__init__).parameters)
+    except (TypeError, ValueError):  # a C-level or wrapped __init__
+        accepted = []
+    for name in ("hf_token", "token", "auth_token", "api_key"):
+        if name in accepted:
+            try:
+                return Client(space_id, **{name: token})
+            except TypeError:
+                break
+    for extra in ({"headers": {"Authorization": f"Bearer {token}"}}, {}):
+        try:
+            return Client(space_id, **extra)
+        except TypeError:
+            continue
+    return Client(space_id)
+
+
+def _remote_plan(client, payload, message):
+    """Ask the Space what it actually exposes, instead of guessing at `/chat`. Endpoint
+    names change with the Gradio version and with how the interface was built, and the
+    parameter list that comes back is the only honest description of the call."""
+    info = None
+    for kwargs in ({"return_format": "dict", "print_info": False}, {"return_format": "dict"}):
+        try:
+            info = client.view_api(**kwargs)
+            break
+        except Exception:  # noqa: BLE001
+            continue
+    named = (info or {}).get("named_endpoints") or {} if isinstance(info, dict) else {}
+    seen = list(named)
+    print(f"[big-space] endpoints: {seen or 'none reported'}", flush=True)
+
+    def rank(name):
+        low = name.lower()
+        if "chat" in low:
+            return 0
+        if any(word in low for word in ("respond", "submit", "predict", "run", "generate")):
+            return 1
+        return 2
+
+    plan = []
+    for name in sorted(named, key=lambda n: (rank(n), n)):
+        params = (named[name] or {}).get("parameters") or []
+        if not params:
+            continue
+        args = []
+        for index, param in enumerate(params):
+            if index == 0:
+                component = str(param.get("component", "")).lower()
+                python_type = str((param.get("python_type") or {}).get("type", "")).lower()
+                # A multimodal box wants {"text": ..., "files": [...]}; a plain one a string.
+                args.append(payload if ("multimodal" in component or "dict" in python_type)
+                            else message)
+            elif param.get("parameter_has_default"):
+                args.append(param.get("parameter_default"))
+            else:
+                args.append(param.get("example_input"))
+        plan.append((tuple(args), {"api_name": name}))
+    return plan, seen
+
+
+def _remote_ask(space_id, message, image_path=None, temperature=0.7):
+    """One turn on a Gradio chat Space. `gradio_client` ships with gradio itself, so
+    there is nothing to add to requirements."""
+    from gradio_client import handle_file
+    from PIL import Image
+
+    client = _REMOTE_CLIENTS.get(space_id)
+    if client is None:
+        client = _make_remote_client(space_id)
+        _REMOTE_CLIENTS[space_id] = client
+
+    files = []
+    if image_path:
+        try:
+            picture = Image.open(image_path).convert("RGB")
+            picture.thumbnail((1024, 1024))
+            handle = tempfile.NamedTemporaryFile(suffix=".jpg", delete=False)
+            picture.save(handle.name, format="JPEG", quality=88)
+            files.append(handle_file(handle.name))
+        except Exception:  # noqa: BLE001
+            files = []
+
+    payload = {"text": message, "files": files}
+    plan, seen = _remote_plan(client, payload, message)
+    attempts = tuple(plan) + (
+        # Only reached when the Space reports nothing useful about itself: a multimodal
+        # ChatInterface with the sampling knobs exposed, the same without them, then a
+        # plain text-in text-out Space.
+        ((payload, "off", temperature, 0.95, 20), {"api_name": "/chat"}),
+        ((payload,), {"api_name": "/chat"}),
+        ((message,), {"api_name": "/chat"}),
+        ((payload, "off", temperature, 0.95, 20), {}),
+        ((message,), {}),
+    )
+    problems = []
+    for args, kwargs in attempts:
+        try:
+            return _remote_reply_text(client.predict(*args, **kwargs))
+        except Exception as error:  # noqa: BLE001
+            problems.append(f"{type(error).__name__}: {error}")
+            print(f"[big-space] attempt failed - {problems[-1]}", flush=True)
+    raise RuntimeError((" || ".join(problems[:2]) + f" || endpoints seen: {seen}")[:600])
+
+
+# The borrowed Space is a small model. Handing it the whole library and asking it to
+# choose is the one job that size of model does badly - it answers by position, repeats
+# itself and invents names that are not on the list. So the long list is cut down here,
+# by plain word matching, and the model is only ever asked to choose between a handful.
+
+_PICK_NOISE = {
+    "ltx", "ltxv", "wan", "wan22", "wan2", "i2v", "t2v", "lora", "loras", "video",
+    "model", "safetensors", "merge", "rank", "version", "experimental", "alpha",
+    "beta", "final", "test", "general", "suite", "helper", "enhancer", "motion",
+    "nsfw", "sfw", "the", "and", "for", "with", "all", "one", "two", "pack",
+    "high", "low", "only", "generic", "slider", "extreme", "ultimate", "booster",
+    "minimax", "mmh3", "h3", "turbo", "step", "steps", "distill", "distilled",
+}
+_PROMPT_NOISE = {
+    "the", "and", "with", "that", "this", "from", "into", "over", "under", "very",
+    "while", "their", "there", "then", "them", "she", "her", "his", "him", "they",
+    "are", "was", "were", "for", "not", "but", "you", "your", "its", "has", "have",
+    "had", "one", "two", "all", "any", "out", "off", "been", "being", "more", "most",
+    "some", "such", "than", "too", "just", "like", "also", "only", "own", "same",
+    "each", "other", "how", "what", "when", "where", "which", "who", "will", "would",
+    "can", "could", "should", "shot", "video", "clip", "camera", "scene", "frame",
+    "light", "lighting", "photorealistic", "realistic", "detailed", "quality",
+    "natural", "smooth", "consistent", "anatomy", "texture", "slowly", "gently",
+    "towards", "toward", "keeps", "keeping", "looking", "looks", "moves", "moving",
+    "sound", "audio", "music", "voice", "dialogue", "speaks", "saying", "picture",
+    # Scenery and plain motion words. These turn up in lora titles as often as they
+    # turn up in prompts, and matching on them is how "a man walking down a rainy
+    # street" ends up wearing a lora about walking with no clothes on.
+    "walk", "walks", "walking", "run", "runs", "running", "stand", "stands",
+    "standing", "sit", "sits", "sitting", "slow", "fast", "quick", "turn", "turns",
+    "turning", "move", "head", "hand", "hands", "body", "woman", "women", "girl",
+    "girls", "man", "men", "guy", "lady", "hair", "face", "eyes", "mouth", "skin",
+    "night", "morning", "street", "city", "room", "bed", "rain", "rainy", "water",
+    "wind", "dress", "shirt", "clothes", "black", "white", "close", "wide", "front",
+    "back", "side", "down", "smile", "smiling", "breathing", "leans", "leaning",
+    "holds", "holding", "takes", "gives", "position", "movement", "style", "character",
+}
+
+
+def _pick_words(text, drop):
+    out = set()
+    for word in re.findall(r"[a-z0-9]+", str(text or "").lower()):
+        if len(word) >= 4 and word not in drop and not word.isdigit():
+            out.add(word)
+    return out
+
+
+def _library_pool():
+    """Every usable library entry, nsfw and ordinary together."""
+    try:
+        data = lora_library.load_library()
+    except Exception as error:  # noqa: BLE001
+        print(f"[simple] the library could not be read: {error}", flush=True)
+        return []
+    pool = []
+    for section in ("nsfw", "normal"):
+        for item in (data.get(section) or []):
+            if isinstance(item, dict) and item.get("url") and item.get("name"):
+                pool.append(item)
+    return pool
+
+
+def _shortlist_loras(prompt_text, pool, limit=6):
+    """The few library entries whose name or trigger words are actually in the prompt."""
+    asked = _pick_words(prompt_text, _PROMPT_NOISE)
+    if not asked:
+        return []
+    scored = []
+    for item in pool:
+        hits = len(asked & _pick_words(item.get("name"), _PICK_NOISE))
+        # A trigger word written out in the prompt is a much stronger signal than a
+        # word that happens to appear in a title, so it counts double.
+        for trigger in str(item.get("trigger") or "").split(","):
+            trigger = trigger.strip().lower()
+            if trigger and trigger in str(prompt_text or "").lower():
+                hits += 2
+        if hits:
+            scored.append((hits, item))
+    scored.sort(key=lambda pair: -pair[0])
+    return [item for _score, item in scored[:limit]]
+
+
+def _pick_label(index, item):
+    text = f"{index + 1}. {item.get('name', '')}"
+    if not str(item.get("trigger") or "").strip():
+        text += "  \u00b7  no trigger words saved"
+    return text[:200]
+
+
+def _ask_which_loras(space_id, prompt_text, shortlist):
+    """One small question: which of these few, by number. Nothing else is asked."""
+    space = str(space_id or "").strip()
+    if not space or not shortlist:
+        return []
+    lines = []
+    for index, item in enumerate(shortlist, start=1):
+        line = f"{index}. {item.get('name', '')}"
+        trigger = str(item.get("trigger") or "").strip()
+        if trigger:
+            line += f"   (words: {trigger})"
+        lines.append(line)
+    message = (
+        "Below is a video prompt and a numbered list of lora files.\n\n"
+        f"PROMPT: {prompt_text}\n\nLIST:\n" + "\n".join(lines) + "\n\n"
+        "Reply with the numbers of at most two entries from the list that match what "
+        "the prompt describes, separated by a comma. Reply with the word NONE if none "
+        "of them match. Write nothing else - no explanation, no names, only numbers."
+    )
+    try:
+        reply = _remote_ask(space, message)
+    except Exception as error:  # noqa: BLE001
+        print(f"[simple] the Space did not answer the pick question: {error}", flush=True)
+        return []
+    if "none" in str(reply or "").lower() and not re.search(r"\d", str(reply or "")):
+        return []
+    picked = []
+    for found in re.findall(r"\d+", str(reply or "")):
+        index = int(found) - 1
+        if 0 <= index < len(shortlist) and index not in picked:
+            picked.append(index)
+    return picked[:2]
+
+
+def _write_prompt(space_id, wanted, image_path):
+    """The description H3 wants, written from the reference picture. Plain prose only -
+    the structured sections are put around it afterwards by the builder this Space
+    already has, which is the part MiniMax call critical to the result."""
+    space = str(space_id or "").strip()
+    if not space:
+        return "", "no Space in the box, so your own words were kept."
+    message = (
+        "Write a single paragraph of about 120 words describing a short video clip, for "
+        "a video model. Describe what is in the picture and what moves: the subject, "
+        "the setting, the action, the light. Present tense, plain prose, no headings, "
+        "no lists, no camera jargon, no preamble - only the paragraph itself.\n\n"
+        f"What is wanted: {wanted}"
+    )
+    try:
+        reply = _remote_ask(space, message, image_path)
+    except Exception as error:  # noqa: BLE001
+        return "", f"{space} did not answer, so your own words were kept: {str(error)[:200]}"
+    written = " ".join(str(reply or "").split())
+    if len(written) < 40:
+        return "", f"{space} answered with almost nothing, so your own words were kept."
+    return written, f"written by {space} ({len(written.split())} words)"
+
+
+def _add_triggers(prompt_text, items):
+    """A lora whose trigger word is missing from the prompt does nothing at all."""
+    text = str(prompt_text or "")
+    missing = []
+    for item in items:
+        # Only the first few. Some entries carry eight phrases and pasting all of them
+        # in buries the sentence the model is meant to be following.
+        for trigger in str(item.get("trigger") or "").split(",")[:3]:
+            trigger = trigger.strip()
+            if trigger and trigger.lower() not in text.lower() and trigger not in missing:
+                missing.append(trigger)
+    if not missing:
+        return text
+    return f"{text.rstrip().rstrip(',')}, {', '.join(missing)}".strip(" ,")
+
+
+def _retune_triggers(prompt_text, shortlist, picks):
+    """Swapping a lora has to take its words back out of the prompt as well."""
+    text = str(prompt_text or "")
+    kept = {str(item.get("url")) for item in picks}
+    for item in shortlist or []:
+        if str(item.get("url")) in kept:
+            continue
+        for trigger in str(item.get("trigger") or "").split(","):
+            trigger = trigger.strip()
+            if trigger:
+                text = re.sub(r"(,\s*)?" + re.escape(trigger) + r"(?=\s*(,|$))",
+                              "", text, flags=re.I)
+    text = re.sub(r"\s*,\s*,", ",", text).strip(" ,")
+    return _add_triggers(text, picks)
+
+
 with gr.Blocks(title="MiniMax-H3 - Custom lora + CivitAI, structured prompts, GPU cost, profiles, stitching") as demo:
     gr.HTML(HERO)
 
+    ui_mode = gr.Radio(
+        [("🟢 Simple — one button writes the prompt and picks the loras", "simple"),
+         ("🔧 Everything — every control this Space has", "pro")],
+        value="simple", show_label=False,
+    )
+
     with gr.Row(equal_height=False):
         with gr.Column(scale=5):
 
@@ -2538,8 +2869,35 @@ with gr.Blocks(title="MiniMax-H3 - Custom lora + CivitAI, structured prompts, GP
                     lines=3,
                     value="The character walks through a neon-lit street in the rain, humming to themselves",
                 )
-                upsample = gr.Checkbox(label="✨ Upsample prompt", value=False)
-                with gr.Accordion("🎬 Structured prompt builder (what H3 was trained on)", open=False):
+                upsample = gr.Checkbox(label="✨ Upsample prompt", value=False, visible=False)
+
+                with gr.Group(elem_classes="panel") as basic_panel:
+                    gr.Markdown(
+                        "**Picture in, a few words above, one press.** The description is "
+                        "written from your first reference picture, wrapped in the labelled "
+                        "sections H3 was trained on, and the library is searched for loras "
+                        "that match it. What it picks is listed underneath and can be "
+                        "changed with a tick."
+                    )
+                    basic_space = gr.Textbox(
+                        value=REMOTE_SPACE, label="🛰️ Big model Space", lines=1,
+                        placeholder="owner/space-name",
+                        info="A chat Space of your own, shown your first picture. Empty it "
+                             "and only the structured builder runs, on your own words.",
+                    )
+                    basic_btn = gr.Button("✨ Do all of it", variant="primary",
+                                          elem_id="ir-btn")
+                    basic_status = gr.Markdown("Nothing done yet.")
+                    basic_pick = gr.CheckboxGroup(
+                        choices=[], value=[], visible=False,
+                        label="Loras it chose — tick another one to swap",
+                        info="Two at a time is the limit. Every tick refills the slots and "
+                             "puts the trigger words into the prompt.",
+                    )
+                    basic_shortlist = gr.State([])
+
+                with gr.Accordion("🎬 Structured prompt builder (what H3 was trained on)",
+                                  open=False, visible=False) as pro_builder:
                     gr.Markdown(
                         "H3 was trained on the output of a preprocessor that rewrites a request into labelled "
                         "sections, and MiniMax call that structure *critical to the quality of the final output*. "
@@ -2566,7 +2924,8 @@ with gr.Blocks(title="MiniMax-H3 - Custom lora + CivitAI, structured prompts, GP
                     ir_button = gr.Button("🎬 Build the structured prompt", variant="secondary",
                                           elem_id="ir-btn")
 
-                with gr.Accordion("💡 Quick tags — click to add", open=False):
+                with gr.Accordion("💡 Quick tags — click to add", open=False,
+                                  visible=False) as pro_chips:
                     with gr.Row(elem_classes="chip-row"):
                         chip_buttons_a = [gr.Button(text, size="sm", variant="secondary") for text in CHIPS[:4]]
                     with gr.Row(elem_classes="chip-row"):
@@ -2634,7 +2993,7 @@ with gr.Blocks(title="MiniMax-H3 - Custom lora + CivitAI, structured prompts, GP
 
             # ---------------- the rest, in tabs ----------------
             with gr.Tabs():
-                with gr.Tab(f"⭐ Custom lora ({LORA_SLOTS} slots)"):
+                with gr.Tab(f"⭐ Custom lora ({LORA_SLOTS} slots)", visible=False) as pro_loratab:
                     gr.Markdown(LORA_HELP)
                     with gr.Accordion("🔍 Search CivitAI", open=False):
                         gr.Markdown(
@@ -2700,17 +3059,19 @@ with gr.Blocks(title="MiniMax-H3 - Custom lora + CivitAI, structured prompts, GP
                     duration = gr.Slider(
                         label="Duration (s)", minimum=MIN_DURATION, maximum=MAX_UI_DURATION, step=1, value=5
                     )
-                    steps = gr.Slider(label="Steps", minimum=MIN_STEPS, maximum=40, step=1, value=28)
-                    with gr.Row():
+                    steps = gr.Slider(label="Steps", minimum=MIN_STEPS, maximum=40, step=1,
+                                      value=28, visible=False)
+                    with gr.Row(visible=False) as pro_seed:
                         seed = gr.Number(label="Seed", value=42, precision=0, scale=3)
                         seed_dice = gr.Button("🎲 roll", variant="secondary", scale=1, elem_id="seed-dice")
                     randomize_seed = gr.Checkbox(
                         label="🎲 Randomize seed on every run",
                         value=True,
+                        visible=False,
                         info="A new seed is drawn each time Generate is pressed, and lands in the box above.",
                     )
 
-                with gr.Tab("💾 Profiles"):
+                with gr.Tab("💾 Profiles", visible=False) as pro_profiles:
                     gr.Markdown(PROFILE_HELP)
                     with gr.Row():
                         profile_picker = gr.Dropdown(
@@ -2753,7 +3114,8 @@ with gr.Blocks(title="MiniMax-H3 - Custom lora + CivitAI, structured prompts, GP
                     2, 8, value=3, step=1, label="How many clips in a row",
                     info="3 clips of 5 s ≈ a 15 second video.",
                 )
-                with gr.Accordion("✍️ A prompt per clip (optional)", open=False):
+                with gr.Accordion("✍️ A prompt per clip (optional)", open=False,
+                                  visible=False) as pro_perclip:
                     scene_prompts = gr.Textbox(
                         label="One line per clip", lines=8, max_lines=8,
                         placeholder=("line 1 = clip 1, line 2 = clip 2, and so on\n"
@@ -2988,6 +3350,103 @@ with gr.Blocks(title="MiniMax-H3 - Custom lora + CivitAI, structured prompts, GP
         api_name=False,
     )
 
+    # ---------------------------------------------------------- simple mode
+
+    def _slot_updates(items):
+        """Fill the first slots with these entries and empty the rest of them.
+
+        Emptying matters - without it yesterday's pick stays loaded underneath today's.
+        """
+        updates = []
+        for index in range(LORA_SLOTS):
+            item = items[index] if index < len(items) else None
+            if item is None:
+                updates.append(gr.update(value=""))
+                updates.append(gr.update())
+            else:
+                updates.append(gr.update(value=str(item.get("url") or "")))
+                updates.append(gr.update(value=float(item.get("strength") or DEFAULT_LORA_SCALE)))
+        return updates
+
+    def _basic_note(picks, extra=""):
+        if not picks:
+            return "No lora added — the prompt is written, that is all." + extra
+        names = ", ".join(str(item.get("name", ""))[:60] for item in picks)
+        blind = [item for item in picks if not str(item.get("trigger") or "").strip()]
+        if blind:
+            extra += (" One of them has no trigger words saved, so it may do nothing; "
+                      "tick a different one if the clip ignores it.")
+        return f"✅ **Loras in:** {names}.{extra}"
+
+    def _basic_run(wanted, space_id, first_image, shot, camera, sound, music,
+                   speaker, dialogue, references, progress=gr.Progress()):
+        progress(0.1, desc="asking the Space (a sleeping one takes a minute to wake)")
+        written, note = _write_prompt(space_id, wanted, first_image)
+        plain = written or str(wanted or "")
+        # The labelled sections go on last, around whatever prose we ended up with.
+        built = build_ir_prompt(plain, shot, camera, sound, music, speaker, dialogue,
+                                references)
+        progress(0.6, desc="searching the library")
+        shortlist = _shortlist_loras(built, _library_pool())
+        if not shortlist:
+            return tuple(
+                [gr.update(value=built), gr.update(choices=[], value=[], visible=False), [],
+                 f"✅ Prompt built — {note}. Nothing in the library matched these words."]
+                + _slot_updates([])
+            )
+        progress(0.8, desc="asking which loras fit")
+        chosen = _ask_which_loras(space_id, built, shortlist) or [0]
+        picks = [shortlist[index] for index in chosen]
+        labels = [_pick_label(index, item) for index, item in enumerate(shortlist)]
+        return tuple(
+            [gr.update(value=_retune_triggers(built, shortlist, picks)),
+             gr.update(choices=labels, value=[labels[i] for i in chosen], visible=True),
+             shortlist,
+             _basic_note(picks, f" Prompt {note}, picked out of {len(shortlist)} that matched.")]
+            + _slot_updates(picks)
+        )
+
+    def _basic_swap(ticked, shortlist, prompt_text):
+        labels = [_pick_label(index, item) for index, item in enumerate(shortlist or [])]
+        wanted = [labels.index(label) for label in (ticked or []) if label in labels]
+        extra = " Two at a time is the limit, so the rest were left out." if len(wanted) > 2 else ""
+        picks = [shortlist[index] for index in wanted[:2]]
+        return tuple(
+            [gr.update(value=_retune_triggers(prompt_text, shortlist, picks)),
+             _basic_note(picks, extra)]
+            + _slot_updates(picks)
+        )
+
+    _BASIC_SLOTS = [field for pair in zip(lora_references, lora_scales) for field in pair]
+
+    basic_btn.click(
+        _basic_run,
+        [prompt, basic_space, images[0], ir_shot, ir_camera, ir_sound, ir_music,
+         ir_speaker, ir_dialogue, ir_references],
+        [prompt, basic_pick, basic_shortlist, basic_status] + _BASIC_SLOTS,
+        api_name=False,
+    )
+
+    # `.input` fires only when the person ticks something; older Gradio has only
+    # `.change`, which also fires when the button above fills the box in. Either is
+    # safe here - a second pass over the same ticks lands on the same answer.
+    _tick_event = getattr(basic_pick, "input", None) or basic_pick.change
+    _tick_event(
+        _basic_swap,
+        [basic_pick, basic_shortlist, prompt],
+        [prompt, basic_status] + _BASIC_SLOTS,
+        api_name=False,
+    )
+
+    _PRO_ONLY = [pro_builder, pro_chips, upsample, pro_loratab, pro_profiles,
+                 steps, pro_seed, randomize_seed, pro_perclip]
+
+    def _switch_mode(mode):
+        pro = str(mode) == "pro"
+        return [gr.update(visible=pro) for _ in _PRO_ONLY] + [gr.update(visible=not pro)]
+
+    ui_mode.change(_switch_mode, [ui_mode], _PRO_ONLY + [basic_panel], api_name=False)
+
     lora_identify_btn.click(identify_loras, lora_references, lora_names, api_name=False)
     for _field in lora_references:
         _field.submit(identify_loras, lora_references, lora_names, api_name=False)