Update app.py

app.py

@@ -30,7 +30,7 @@ logging.basicConfig(
     handlers=[logging.StreamHandler(sys.stdout)],
 )
 logger = logging.getLogger("NextGenEngine")
-logger.info("🚀 JustinD Fiction Lab boot (21+ · Multi-chef stacks · sexy UI)")
+logger.info("🚀 JustinD Fiction Lab boot (21+ · multi-select stacks · optional quad chefs)")
 
 if hasattr(sys.stdout, "reconfigure"):
     sys.stdout.reconfigure(encoding="utf-8")
@@ -41,6 +41,7 @@ BACKUP_DATASET_ID = "JustinD/generation-images"
 LAST_GEN_TIME = {}
 COOLDOWN_SECONDS = 12
 LOG_VISITOR_UPLOADS = os.environ.get("LOG_VISITOR_UPLOADS", "0").strip().lower() in {"1", "true", "yes"}
+MAX_STACK_BATCH_PRODUCT = 6
 
 HF_REPO_ID = "AriaVale2/my-safetensors-backup"
 
@@ -106,6 +107,8 @@ DIFFUSERS_MODELS = {
 }
 
 SDXL_CHOICES = list(DIFFUSERS_MODELS.keys()) + list(MODEL_REPOS.keys())
+SKIP_CHEF = "(skip)"
+CHEF_OPTIONAL_CHOICES = [SKIP_CHEF] + SDXL_CHOICES
 
 # LoRA pantry from known SDXL repos. Fail soft if download/load breaks.
 LORA_NONE = "None"
@@ -121,9 +124,9 @@ LORA_REPOS = {
 }
 LORA_CHOICES = list(LORA_REPOS.keys())
 
-# Named multi-chef stacks. Every gen = Chef A txt2img then Chef B img2img remix.
-# Default stack = filthiest (AI + AI x AI) with sexy-slider LoRA.
-# Lots of mixes so Justin can shop output vibes. Plain UI; stacks are the product.
+# Named multi-chef stacks. Schema supports optional Chef C/D (quad).
+# Two-chef stacks keep chef_c/d=None. Quad stacks set all four.
+# LoRA applies on the last chef that actually runs.
 STACK_PHOTO_ILLUSTRIOUS = "Photo + Illustrious"
 STACK_HARDCORE_FACE = "Hardcore + face keeper"
 STACK_ANIME_REAL = "Anime Desire × Real Porn"
@@ -138,95 +141,125 @@ STACK_FACE_ILLUSTRIOUS = "Face keeper × Illustrious"
 STACK_SPICY_WAI = "Spicy Realism × WAI"
 STACK_FUCKTASTIC_REAL = "Fucktastic × Real Porn"
 STACK_EGIRL_LUSTIFY = "Asian E-Girl × Lustify"
+STACK_QUAD_LUSTIFY_REAL_WAI_FACE = "Quad: Lustify → Real → WAI → Face"
+STACK_QUAD_HARDCORE_LUSTIFY_ILLU_REAL = "Quad: Hardcore → Lustify → Illustrious → Real"
+STACK_QUAD_ANIME_REAL_WAI_LUSTIFY = "Quad: Anime Desire → Real → WAI → Lustify"
+STACK_QUAD_EGIRL_LUSTIFY_WAI_FACE = "Quad: E-Girl → Lustify → WAI → Face"
+
+
+def _two(chef_a, chef_b, lora, blend_b):
+    return {
+        "chef_a": chef_a,
+        "chef_b": chef_b,
+        "chef_c": None,
+        "chef_d": None,
+        "lora": lora,
+        "blend_b": float(blend_b),
+        "blend_c": 0.50,
+        "blend_d": 0.45,
+    }
+
+
+def _quad(chef_a, chef_b, chef_c, chef_d, lora, blend_b, blend_c, blend_d):
+    return {
+        "chef_a": chef_a,
+        "chef_b": chef_b,
+        "chef_c": chef_c,
+        "chef_d": chef_d,
+        "lora": lora,
+        "blend_b": float(blend_b),
+        "blend_c": float(blend_c),
+        "blend_d": float(blend_d),
+    }
+
 
 STACKS = {
-    STACK_PHOTO_ILLUSTRIOUS: {
-        "chef_a": "PornWorks Real Porn v04",
-        "chef_b": "WAI NSFW Illustrious v150",
-        "lora": LORA_NONE,
-        "blend": 0.50,
-    },
-    STACK_HARDCORE_FACE: {
-        "chef_a": "Hardcore Asian Cosplay Illustrious",
-        "chef_b": "OhMySister Beautiful Asian Woman",
-        "lora": LORA_NONE,
-        "blend": 0.60,
-    },
-    STACK_ANIME_REAL: {
-        "chef_a": "PornWorks Anime Desire NSFW",
-        "chef_b": "PornWorks Real Porn v04",
-        "lora": LORA_NONE,
-        "blend": 0.55,
-    },
-    STACK_AI_AI_AI: {
-        "chef_a": "Lustify NSFW GGWP v7",
-        "chef_b": "WAI NSFW Illustrious v150",
-        "lora": "sexy-slider (Soft Domme heat)",
-        "blend": 0.55,
-    },
-    STACK_SOFT_DOMME: {
-        "chef_a": "Lustify NSFW GGWP v7",
-        "chef_b": "Lustify NSFW Endgame",
-        "lora": "sexy-slider (Soft Domme heat)",
-        "blend": 0.62,
-    },
-    STACK_MIRROR_HOTEL: {
-        "chef_a": "PornWorks Real Porn v04",
-        "chef_b": "WAI NSFW Illustrious v150",
-        "lora": LORA_NONE,
-        "blend": 0.48,
-    },
-    STACK_NEON_ALLEY: {
-        "chef_a": "Hardcore Asian Cosplay Illustrious",
-        "chef_b": "Lustify NSFW GGWP v7",
-        "lora": LORA_NONE,
-        "blend": 0.58,
-    },
-    STACK_LUSTIFY_REAL: {
-        "chef_a": "Lustify NSFW GGWP v7",
-        "chef_b": "PornWorks Real Porn v04",
-        "lora": LORA_NONE,
-        "blend": 0.52,
-    },
-    STACK_ANIME_ILLUSTRIOUS: {
-        "chef_a": "PornWorks Anime Desire NSFW",
-        "chef_b": "WAI NSFW Illustrious v150",
-        "lora": LORA_NONE,
-        "blend": 0.55,
-    },
-    STACK_HARDCORE_LUSTIFY: {
-        "chef_a": "Hardcore Asian Cosplay Illustrious",
-        "chef_b": "Lustify NSFW One Last Time",
-        "lora": LORA_NONE,
-        "blend": 0.57,
-    },
-    STACK_FACE_ILLUSTRIOUS: {
-        "chef_a": "OhMySister Beautiful Asian Woman",
-        "chef_b": "WAI NSFW Illustrious v150",
-        "lora": LORA_NONE,
-        "blend": 0.50,
-    },
-    STACK_SPICY_WAI: {
-        "chef_a": "Spicy Realism NSFW Mix v3",
-        "chef_b": "WAI NSFW Illustrious v150",
-        "lora": LORA_NONE,
-        "blend": 0.53,
-    },
-    STACK_FUCKTASTIC_REAL: {
-        "chef_a": "Fucktastic Real Porn Pony v5.1",
-        "chef_b": "PornWorks Real Porn v04",
-        "lora": LORA_NONE,
-        "blend": 0.54,
-    },
-    STACK_EGIRL_LUSTIFY: {
-        "chef_a": "Asian E-Girl NSFW XL",
-        "chef_b": "Lustify NSFW GGWP v7",
-        "lora": "sexy-slider (Soft Domme heat)",
-        "blend": 0.56,
-    },
+    STACK_PHOTO_ILLUSTRIOUS: _two(
+        "PornWorks Real Porn v04", "WAI NSFW Illustrious v150", LORA_NONE, 0.50
+    ),
+    STACK_HARDCORE_FACE: _two(
+        "Hardcore Asian Cosplay Illustrious", "OhMySister Beautiful Asian Woman", LORA_NONE, 0.60
+    ),
+    STACK_ANIME_REAL: _two(
+        "PornWorks Anime Desire NSFW", "PornWorks Real Porn v04", LORA_NONE, 0.55
+    ),
+    STACK_AI_AI_AI: _two(
+        "Lustify NSFW GGWP v7", "WAI NSFW Illustrious v150", "sexy-slider (Soft Domme heat)", 0.55
+    ),
+    STACK_SOFT_DOMME: _two(
+        "Lustify NSFW GGWP v7", "Lustify NSFW Endgame", "sexy-slider (Soft Domme heat)", 0.62
+    ),
+    STACK_MIRROR_HOTEL: _two(
+        "PornWorks Real Porn v04", "WAI NSFW Illustrious v150", LORA_NONE, 0.48
+    ),
+    STACK_NEON_ALLEY: _two(
+        "Hardcore Asian Cosplay Illustrious", "Lustify NSFW GGWP v7", LORA_NONE, 0.58
+    ),
+    STACK_LUSTIFY_REAL: _two(
+        "Lustify NSFW GGWP v7", "PornWorks Real Porn v04", LORA_NONE, 0.52
+    ),
+    STACK_ANIME_ILLUSTRIOUS: _two(
+        "PornWorks Anime Desire NSFW", "WAI NSFW Illustrious v150", LORA_NONE, 0.55
+    ),
+    STACK_HARDCORE_LUSTIFY: _two(
+        "Hardcore Asian Cosplay Illustrious", "Lustify NSFW One Last Time", LORA_NONE, 0.57
+    ),
+    STACK_FACE_ILLUSTRIOUS: _two(
+        "OhMySister Beautiful Asian Woman", "WAI NSFW Illustrious v150", LORA_NONE, 0.50
+    ),
+    STACK_SPICY_WAI: _two(
+        "Spicy Realism NSFW Mix v3", "WAI NSFW Illustrious v150", LORA_NONE, 0.53
+    ),
+    STACK_FUCKTASTIC_REAL: _two(
+        "Fucktastic Real Porn Pony v5.1", "PornWorks Real Porn v04", LORA_NONE, 0.54
+    ),
+    STACK_EGIRL_LUSTIFY: _two(
+        "Asian E-Girl NSFW XL", "Lustify NSFW GGWP v7", "sexy-slider (Soft Domme heat)", 0.56
+    ),
+    STACK_QUAD_LUSTIFY_REAL_WAI_FACE: _quad(
+        "Lustify NSFW GGWP v7",
+        "PornWorks Real Porn v04",
+        "WAI NSFW Illustrious v150",
+        "OhMySister Beautiful Asian Woman",
+        LORA_NONE,
+        0.55,
+        0.50,
+        0.42,
+    ),
+    STACK_QUAD_HARDCORE_LUSTIFY_ILLU_REAL: _quad(
+        "Hardcore Asian Cosplay Illustrious",
+        "Lustify NSFW GGWP v7",
+        "WAI NSFW Illustrious v150",
+        "PornWorks Real Porn v04",
+        LORA_NONE,
+        0.55,
+        0.50,
+        0.45,
+    ),
+    STACK_QUAD_ANIME_REAL_WAI_LUSTIFY: _quad(
+        "PornWorks Anime Desire NSFW",
+        "PornWorks Real Porn v04",
+        "WAI NSFW Illustrious v150",
+        "Lustify NSFW GGWP v7",
+        LORA_NONE,
+        0.55,
+        0.50,
+        0.48,
+    ),
+    STACK_QUAD_EGIRL_LUSTIFY_WAI_FACE: _quad(
+        "Asian E-Girl NSFW XL",
+        "Lustify NSFW GGWP v7",
+        "WAI NSFW Illustrious v150",
+        "OhMySister Beautiful Asian Woman",
+        "sexy-slider (Soft Domme heat)",
+        0.55,
+        0.50,
+        0.42,
+    ),
 }
 STACK_CHOICES = list(STACKS.keys())
 DEFAULT_STACK = STACK_AI_AI_AI
+DEFAULT_STACKS = [DEFAULT_STACK]
 
 # Style packs stack via CheckboxGroup. Testing Tits is the heat base; scene packs layer on top.
 # Cosmic e-girl booth is FICTIONAL DJ only (no real person names).
@@ -532,7 +565,7 @@ def _apply_lora(pipe, lora_name: str) -> bool:
         logger.info(f"✅ LoRA applied: {lora_name}")
         return True
     except Exception as e:
-        logger.error(f"⚠️ LoRA load failed for {lora_name}: {e} (continuing A+B blend alone)")
+        logger.error(f"⚠️ LoRA load failed for {lora_name}: {e} (continuing chef chain alone)")
         return False
 
 
@@ -585,29 +618,194 @@ def enhance_prompt(prompt, styles, filth_level=1):
     return ", ".join([p for p in parts if p])
 
 
-def resolve_stack_slots(stack_name, chef_a, chef_b, lora_name, blend):
-    """Use Advanced overrides when set; fill gaps from named stack."""
-    cfg = STACKS.get(stack_name) or STACKS[DEFAULT_STACK]
-    a = chef_a if chef_a and str(chef_a).strip() else cfg["chef_a"]
-    b = chef_b if chef_b and str(chef_b).strip() else cfg["chef_b"]
-    lora = lora_name if lora_name else cfg["lora"]
+def _norm_chef(name):
+    if name is None:
+        return None
+    s = str(name).strip()
+    if not s or s == SKIP_CHEF or s.lower() in {"none", "null", "skip"}:
+        return None
+    return s
+
+
+def _clamp_blend(val, fallback=0.55):
     try:
-        strength = float(blend)
+        strength = float(val)
     except (TypeError, ValueError):
-        strength = float(cfg["blend"])
-    strength = max(0.05, min(0.95, strength))
-    return a, b, lora, strength
+        strength = float(fallback)
+    return max(0.05, min(0.95, strength))
+
+
+def resolve_chef_chain(cfg):
+    """Build ordered chef list from a stack cfg. Stops after last filled chef.
+    Returns (chefs, blends, lora) where chefs[0]=A (txt2img), rest are img2img.
+    blends aligns with chefs[1:] (blend for B/C/D).
+    """
+    a = _norm_chef(cfg.get("chef_a"))
+    b = _norm_chef(cfg.get("chef_b"))
+    c = _norm_chef(cfg.get("chef_c"))
+    d = _norm_chef(cfg.get("chef_d"))
+    if not a:
+        raise ValueError("Chef A is required")
+    chefs = [a]
+    blends = []
+    if b:
+        chefs.append(b)
+        blends.append(_clamp_blend(cfg.get("blend_b", 0.55)))
+        if c:
+            chefs.append(c)
+            blends.append(_clamp_blend(cfg.get("blend_c", 0.50)))
+            if d:
+                chefs.append(d)
+                blends.append(_clamp_blend(cfg.get("blend_d", 0.45)))
+    lora = cfg.get("lora") or LORA_NONE
+    return chefs, blends, lora
+
+
+def _make_img2img(pipe):
+    from diffusers import StableDiffusionXLImg2ImgPipeline
+
+    img2img = StableDiffusionXLImg2ImgPipeline(
+        vae=pipe.vae,
+        text_encoder=pipe.text_encoder,
+        text_encoder_2=pipe.text_encoder_2,
+        tokenizer=pipe.tokenizer,
+        tokenizer_2=pipe.tokenizer_2,
+        unet=pipe.unet,
+        scheduler=pipe.scheduler,
+    )
+    if torch.cuda.is_available():
+        img2img = img2img.to("cuda")
+    return img2img
 
 
-@spaces.GPU(duration=240) if SPACES_AVAILABLE else (lambda f: f)
+def run_chef_pipeline(
+    stack_label,
+    cfg,
+    enhanced,
+    neg,
+    seeds,
+    use_steps,
+    remix_steps,
+    cfg_scale,
+    width,
+    height,
+    device,
+):
+    """Run A txt2img then optional B/C/D img2img with unload between chefs.
+    LoRA applies on the last chef that runs.
+    Returns list of (pil_image, seed, chain_str, label).
+    """
+    chefs, blends, lora = resolve_chef_chain(cfg)
+    last_idx = len(chefs) - 1
+    lora_tag = lora if lora and lora != LORA_NONE else "no-LoRA"
+
+    # Pass A: txt2img (never LoRA on A unless A is the only chef, which should not happen)
+    lora_a = lora if last_idx == 0 else LORA_NONE
+    pipe_a = load_sdxl_pipe(chefs[0], lora_a)
+    current = []
+    for s in seeds:
+        gen = torch.Generator(device=device).manual_seed(int(s))
+        out = pipe_a(
+            prompt=enhanced,
+            negative_prompt=neg,
+            num_inference_steps=use_steps,
+            guidance_scale=float(cfg_scale),
+            width=int(width),
+            height=int(height),
+            generator=gen,
+        ).images[0]
+        current.append((out, s))
+
+    letter_names = ["A", "B", "C", "D"]
+    chain_bits = [f"A:{chefs[0]}"]
+
+    # Passes B/C/D: img2img remix, unload between, LoRA only on last chef
+    for pass_i, chef_name in enumerate(chefs[1:], start=1):
+        unload_all()
+        strength = blends[pass_i - 1]
+        lora_here = lora if pass_i == last_idx else LORA_NONE
+        pipe_n = load_sdxl_pipe(chef_name, lora_here)
+        img2img = _make_img2img(pipe_n)
+        remixed = []
+        seed_offset = 17 * pass_i
+        for img, s in current:
+            gen = torch.Generator(device=device).manual_seed(int(s) + seed_offset)
+            out = img2img(
+                image=img,
+                prompt=enhanced,
+                negative_prompt=neg,
+                strength=float(strength),
+                num_inference_steps=remix_steps,
+                guidance_scale=float(cfg_scale),
+                generator=gen,
+            ).images[0]
+            remixed.append((out, s))
+        current = remixed
+        letter = letter_names[pass_i] if pass_i < len(letter_names) else f"P{pass_i}"
+        chain_bits.append(f"{letter}:{chef_name}@{strength:.2f}")
+        del img2img
+        gc.collect()
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+
+    chain = f"{stack_label} | {' → '.join(chain_bits)} | {lora_tag}"
+    results = []
+    for out, s in current:
+        label = f"{stack_label} · seed {s}"
+        results.append((out, s, chain, label))
+    return results
+
+
+def normalize_selected_stacks(selected):
+    if not selected:
+        return list(DEFAULT_STACKS)
+    if isinstance(selected, str):
+        selected = [selected]
+    out = [s for s in selected if s in STACKS]
+    return out if out else list(DEFAULT_STACKS)
+
+
+def clamp_batch_for_stacks(n_stacks, batch):
+    """Cap stacks × batch to avoid ZeroGPU timeout. Prefer batch=1 when 3+ stacks."""
+    batch = int(max(1, min(3, int(batch))))
+    warn = ""
+    if n_stacks * batch > MAX_STACK_BATCH_PRODUCT:
+        if n_stacks >= 3:
+            batch = 1
+            warn = f"Batch forced to 1 (selected {n_stacks} stacks; stacks×batch cap is {MAX_STACK_BATCH_PRODUCT})."
+        else:
+            batch = max(1, MAX_STACK_BATCH_PRODUCT // max(1, n_stacks))
+            warn = f"Batch reduced to {batch} (selected {n_stacks} stacks; stacks×batch cap is {MAX_STACK_BATCH_PRODUCT})."
+    return batch, warn
+
+
+def advanced_cfg_from_ui(chef_a, chef_b, chef_c, chef_d, lora_name, blend_b, blend_c, blend_d):
+    return {
+        "chef_a": _norm_chef(chef_a) or STACKS[DEFAULT_STACK]["chef_a"],
+        "chef_b": _norm_chef(chef_b) or STACKS[DEFAULT_STACK]["chef_b"],
+        "chef_c": _norm_chef(chef_c),
+        "chef_d": _norm_chef(chef_d),
+        "lora": lora_name if lora_name else LORA_NONE,
+        "blend_b": _clamp_blend(blend_b, 0.55),
+        "blend_c": _clamp_blend(blend_c, 0.50),
+        "blend_d": _clamp_blend(blend_d, 0.45),
+    }
+
+
+@spaces.GPU(duration=360) if SPACES_AVAILABLE else (lambda f: f)
 def generate(
     prompt,
     styles,
-    stack_name,
+    selected_stacks,
     chef_a,
     chef_b,
+    chef_c,
+    chef_d,
     lora_name,
-    blend,
+    blend_b,
+    blend_c,
+    blend_d,
+    use_advanced,
     steps,
     cfg,
     seed,
@@ -615,11 +813,8 @@ def generate(
     height,
     batch,
     filth_level,
-    age_ok,
     username,
 ):
-    if not age_ok:
-        return None, "❌ Confirm you are 21+ before cooking", "", []
     if not prompt or not str(prompt).strip():
         return None, "❌ Prompt missing", "", []
     now = time.time()
@@ -633,86 +828,61 @@ def generate(
         gr.Warning("Restricted content")
         return None, "❌ Restricted content", "", []
 
-    batch = int(max(1, min(3, int(batch))))
+    use_advanced = bool(use_advanced)
+    stacks = normalize_selected_stacks(selected_stacks)
+    if use_advanced:
+        # Single custom path: Advanced overrides ignore named stacks
+        run_jobs = [("Advanced override", advanced_cfg_from_ui(
+            chef_a, chef_b, chef_c, chef_d, lora_name, blend_b, blend_c, blend_d
+        ))]
+        n_paths = 1
+    else:
+        run_jobs = [(name, STACKS[name]) for name in stacks]
+        n_paths = len(run_jobs)
+
+    batch, batch_warn = clamp_batch_for_stacks(n_paths, batch)
     seeds = [
         random.randint(0, 2**31 - 1) if int(seed) < 0 else int(seed) + i
         for i in range(batch)
     ]
     enhanced = enhance_prompt(prompt, styles, filth_level)
     neg = BASE_NEGATIVES
-
-    model_a, model_b, lora, strength = resolve_stack_slots(
-        stack_name, chef_a, chef_b, lora_name, blend
-    )
     use_steps = int(max(10, min(40, int(steps))))
     remix_steps = max(10, int(use_steps * 0.75))
     LAST_GEN_TIME[user_key] = now
     gallery = []
     jobs = []
+    info_bits = []
+    if batch_warn:
+        info_bits.append(batch_warn)
+        gr.Warning(batch_warn)
     device = "cuda" if torch.cuda.is_available() else "cpu"
 
     try:
-        # Pass A: txt2img with Chef A
-        pipe_a = load_sdxl_pipe(model_a, LORA_NONE)
-        base_images = []
-        for s in seeds:
-            gen = torch.Generator(device=device).manual_seed(int(s))
-            out = pipe_a(
-                prompt=enhanced,
-                negative_prompt=neg,
-                num_inference_steps=use_steps,
-                guidance_scale=float(cfg),
-                width=int(width),
-                height=int(height),
-                generator=gen,
-            ).images[0]
-            base_images.append((out, s))
-
-        # Unload A, load B (+ optional LoRA), img2img remix
-        unload_all()
-        from diffusers import StableDiffusionXLImg2ImgPipeline
-
-        pipe_b = load_sdxl_pipe(model_b, lora)
-        img2img = StableDiffusionXLImg2ImgPipeline(
-            vae=pipe_b.vae,
-            text_encoder=pipe_b.text_encoder,
-            text_encoder_2=pipe_b.text_encoder_2,
-            tokenizer=pipe_b.tokenizer,
-            tokenizer_2=pipe_b.tokenizer_2,
-            unet=pipe_b.unet,
-            scheduler=pipe_b.scheduler,
-        )
-        if torch.cuda.is_available():
-            img2img = img2img.to("cuda")
-
-        remixed = []
-        for img, s in base_images:
-            gen = torch.Generator(device=device).manual_seed(int(s) + 17)
-            out = img2img(
-                image=img,
-                prompt=enhanced,
-                negative_prompt=neg,
-                strength=float(strength),
-                num_inference_steps=remix_steps,
-                guidance_scale=float(cfg),
-                generator=gen,
-            ).images[0]
-            remixed.append((out, s))
-        del img2img
-        gc.collect()
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
-
-        lora_tag = lora if lora and lora != LORA_NONE else "no-LoRA"
-        chain = f"{stack_name} | A:{model_a} → B:{model_b}@{strength:.2f} | {lora_tag}"
-        for out, s in remixed:
-            label = f"seed {s} · {stack_name} · A→B {strength:.2f}"
-            gallery.append((out, label))
-            jobs.append((out, s, chain, prompt, username, width, height, use_steps, cfg))
+        for stack_label, cfg in run_jobs:
+            results = run_chef_pipeline(
+                stack_label=stack_label,
+                cfg=cfg,
+                enhanced=enhanced,
+                neg=neg,
+                seeds=seeds,
+                use_steps=use_steps,
+                remix_steps=remix_steps,
+                cfg_scale=cfg,
+                width=width,
+                height=height,
+                device=device,
+            )
+            for out, s, chain, label in results:
+                gallery.append((out, label))
+                jobs.append((out, s, chain, prompt, username, width, height, use_steps, cfg))
+                info_bits.append(chain)
+            unload_all()
 
         info = (
-            f"{chain} | seeds {seeds} | {width}x{height} | "
-            f"steps A={use_steps} B={remix_steps} | filth={filth_level} | enhanced prompt ready"
+            f"{' || '.join(info_bits)} | seeds {seeds} | {width}x{height} | "
+            f"steps A={use_steps} remix={remix_steps} | filth={filth_level} | "
+            f"paths={n_paths} batch={batch} | enhanced prompt ready"
         )
         return gallery, info, enhanced, jobs
     except Exception as e:
@@ -723,13 +893,30 @@ def generate(
         return None, f"❌ {msg}", "", []
 
 
-def on_stack_change(stack_name):
-    cfg = STACKS.get(stack_name) or STACKS[DEFAULT_STACK]
+def on_stacks_change(selected):
+    """Sync Advanced slots when exactly one named stack is selected."""
+    stacks = normalize_selected_stacks(selected)
+    if len(stacks) != 1:
+        return (
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            gr.update(),
+            gr.update(),
+        )
+    cfg = STACKS[stacks[0]]
     return (
         gr.update(value=cfg["chef_a"]),
         gr.update(value=cfg["chef_b"]),
+        gr.update(value=cfg["chef_c"] if cfg.get("chef_c") else SKIP_CHEF),
+        gr.update(value=cfg["chef_d"] if cfg.get("chef_d") else SKIP_CHEF),
         gr.update(value=cfg["lora"]),
-        gr.update(value=cfg["blend"]),
+        gr.update(value=cfg["blend_b"]),
+        gr.update(value=cfg["blend_c"]),
+        gr.update(value=cfg["blend_d"]),
     )
 
 
@@ -766,26 +953,23 @@ def create_ui():
         user_id = gr.Textbox(visible=False)
         gr.Markdown(
             """# JustinD/1 · 21+ Fiction Lab
-### Adult East / Southeast Asian fiction booth · Multi-chef stacks · ZeroGPU
+### Adult East / Southeast Asian fiction booth · Multi-select stacks · optional quad chefs · ZeroGPU
 
 **Fiction only. Adult women 21+ (late 20s). No real dating names or faces.**
 Body lock baked in: tall slim small frame, tiny waist, large / full / heavy breasts, cleavage.
-Every cook runs **Chef A txt2img → unload → Chef B img2img remix**.
+Every cook runs **Chef A txt2img → unload → Chef B img2img** (then optional C / D).
+Pick **multiple named stacks** to cook several recipes into one gallery (same prompt / styles / filth / seed base).
+**GPU time tip:** stacks × batch is capped at 6. Selecting 3+ stacks forces batch=1.
 Cosmic e-girl booth = fictional DJ only. Negatives stay built-in (not editable).
 Visitor gens are **not** saved unless secret `LOG_VISITOR_UPLOADS=1`.
 First model load is slow. Queues happen on ZeroGPU."""
         )
-        with gr.Row(elem_classes=["age-gate"]):
-            age_ok = gr.Checkbox(
-                label="I confirm I am 21+ and want adult fiction only",
-                value=False,
-            )
         with gr.Row():
             with gr.Column(scale=5):
-                stack = gr.Radio(
-                    label="Named stack (pick a chip)",
+                stacks = gr.CheckboxGroup(
+                    label="Named stacks (multi-select · empty = AI + AI × AI alone)",
                     choices=STACK_CHOICES,
-                    value=DEFAULT_STACK,
+                    value=list(DEFAULT_STACKS),
                 )
                 styles = gr.CheckboxGroup(
                     label="Style packs (stackable · Testing Tits on by default)",
@@ -809,7 +993,15 @@ First model load is slow. Queues happen on ZeroGPU."""
                     step=1,
                 )
                 go = gr.Button("🔥 GENERATE", variant="primary", size="lg")
-                with gr.Accordion("Advanced (Chef A/B · LoRA · blend · size)", open=False):
+                with gr.Accordion("Advanced (Chef A/B/C/D · LoRA · blends · size)", open=False):
+                    use_advanced = gr.Checkbox(
+                        label="Use Advanced override (ignore stack chefs)",
+                        value=False,
+                    )
+                    gr.Markdown(
+                        "When override is **off**, each selected stack uses its own chefs. "
+                        "When **on**, one custom path uses the Advanced slots below (C/D can be skip)."
+                    )
                     chef_a = gr.Dropdown(
                         label="Chef A (txt2img base)",
                         choices=SDXL_CHOICES,
@@ -820,21 +1012,51 @@ First model load is slow. Queues happen on ZeroGPU."""
                         choices=SDXL_CHOICES,
                         value=default_cfg["chef_b"],
                     )
+                    chef_c = gr.Dropdown(
+                        label="Chef C (optional img2img)",
+                        choices=CHEF_OPTIONAL_CHOICES,
+                        value=SKIP_CHEF,
+                    )
+                    chef_d = gr.Dropdown(
+                        label="Chef D (optional img2img)",
+                        choices=CHEF_OPTIONAL_CHOICES,
+                        value=SKIP_CHEF,
+                    )
                     lora_dd = gr.Dropdown(
-                        label="LoRA (None = blend only)",
+                        label="LoRA on last chef that runs (None = blend only)",
                         choices=LORA_CHOICES,
                         value=default_cfg["lora"],
                     )
-                    blend_sl = gr.Slider(
-                        label="Blend A→B strength (higher = more Chef B)",
+                    blend_b_sl = gr.Slider(
+                        label="Blend B strength (higher = more Chef B)",
+                        minimum=0.30,
+                        maximum=0.70,
+                        value=default_cfg["blend_b"],
+                        step=0.05,
+                    )
+                    blend_c_sl = gr.Slider(
+                        label="Blend C strength (if Chef C set)",
+                        minimum=0.30,
+                        maximum=0.70,
+                        value=default_cfg["blend_c"],
+                        step=0.05,
+                    )
+                    blend_d_sl = gr.Slider(
+                        label="Blend D strength (if Chef D set)",
                         minimum=0.30,
                         maximum=0.70,
-                        value=default_cfg["blend"],
+                        value=default_cfg["blend_d"],
                         step=0.05,
                     )
                     with gr.Row():
                         seed = gr.Number(label="Seed (-1 = random / lucky)", value=-1, precision=0)
-                        batch = gr.Slider(1, 3, value=1, step=1, label="Batch (1 safe · 2-3 may OOM)")
+                        batch = gr.Slider(
+                            1,
+                            3,
+                            value=1,
+                            step=1,
+                            label="Batch (1 safe · stacks×batch capped at 6 · 3+ stacks force batch=1)",
+                        )
                     with gr.Row():
                         width = gr.Slider(512, 1536, value=1024, step=64, label="Width")
                         height = gr.Slider(512, 1536, value=1024, step=64, label="Height")
@@ -850,15 +1072,15 @@ First model load is slow. Queues happen on ZeroGPU."""
                     object_fit="contain",
                     preview=True,
                 )
-                info = gr.Textbox(label="Run info", lines=2)
+                info = gr.Textbox(label="Run info", lines=3)
                 meta = gr.Textbox(label="Enhanced prompt (auto)", lines=4)
 
         demo.load(fn=None, inputs=None, outputs=user_id, js=js_visitor)
 
-        stack.change(
-            fn=on_stack_change,
-            inputs=[stack],
-            outputs=[chef_a, chef_b, lora_dd, blend_sl],
+        stacks.change(
+            fn=on_stacks_change,
+            inputs=[stacks],
+            outputs=[chef_a, chef_b, chef_c, chef_d, lora_dd, blend_b_sl, blend_c_sl, blend_d_sl],
         )
         lucky_prompt_btn.click(fn=random_starter, inputs=None, outputs=prompt)
         lucky_seed_btn.click(fn=lucky_seed, inputs=None, outputs=seed)
@@ -877,11 +1099,16 @@ First model load is slow. Queues happen on ZeroGPU."""
             inputs=[
                 prompt,
                 styles,
-                stack,
+                stacks,
                 chef_a,
                 chef_b,
+                chef_c,
+                chef_d,
                 lora_dd,
-                blend_sl,
+                blend_b_sl,
+                blend_c_sl,
+                blend_d_sl,
+                use_advanced,
                 steps,
                 cfg,
                 seed,
@@ -889,7 +1116,6 @@ First model load is slow. Queues happen on ZeroGPU."""
                 height,
                 batch,
                 filth,
-                age_ok,
                 user_id,
             ],
             outputs=[gallery, info, meta],
@@ -902,4 +1128,3 @@ if __name__ == "__main__":
     app = create_ui()
     app.queue(max_size=12)
     app.launch(ssr_mode=False, theme=THEME, css=css)
-