Deploy architectural upgrades: VRAM CPU offloading, sequential task queue, pipeline registry, and SQLite database manager

.gitignore

@@ -6,3 +6,5 @@ weights/
 audit_log.jsonl
 train_log.json
 .DS_Store
+*.db
+

app.py

@@ -5,6 +5,7 @@ import json
 import base64
 import threading
 import uuid
+import concurrent.futures
 from io import BytesIO
 from typing import Optional, Dict, Any
 from fastapi import FastAPI, Request, HTTPException, BackgroundTasks, Depends
@@ -20,6 +21,7 @@ from lumaforge.safety import SafetyManager
 from lumaforge.benchmark import BenchmarkSuite
 from lumaforge.dataset_curator import DatasetCurator
 from lumaforge.train import LumaForgeTrainer
+from lumaforge.database import DatabaseManager
 
 # Session management for async generation
 class GenerationSession:
@@ -106,9 +108,30 @@ app.add_middleware(
 # Singletons for backend resources
 ollama_client = OllamaClient()
 safety_manager = SafetyManager(ollama_client=ollama_client)
-pipeline = LumaForgePipeline(device="mps", ollama_client=ollama_client)
+db_manager = DatabaseManager()
+
+class PipelineRegistry:
+    def __init__(self, ollama_client):
+        self.ollama_client = ollama_client
+        self._cache = {}
+        self._lock = threading.Lock()
+
+    def get_pipeline(self, device: str) -> LumaForgePipeline:
+        with self._lock:
+            if device not in self._cache:
+                print(f"[PipelineRegistry] Creating and caching pipeline instance for device: {device}")
+                self._cache[device] = LumaForgePipeline(device=device, ollama_client=self.ollama_client)
+            return self._cache[device]
+
+pipeline_registry = PipelineRegistry(ollama_client=ollama_client)
+# Keep global reference to default 'mps' pipeline for backwards compatibility/direct usage
+pipeline = pipeline_registry.get_pipeline("mps")
+
 session_manager = SessionManager()
 
+# Sequential generation queue executor to prevent VRAM / hardware OOM
+generation_executor = concurrent.futures.ThreadPoolExecutor(max_workers=1)
+
 # Background training tracking
 training_thread = None
 
@@ -546,6 +569,18 @@ def api_generate(req: GenerateRequest, request: Request):
     mod_res = safety_manager.moderate_prompt(req.prompt)
     
     if mod_res["status"] == "REFUSED":
+        # Log refusal to database
+        db_manager.log_generation(
+            session_id=f"direct-refused-{uuid.uuid4()}",
+            prompt=req.prompt,
+            status="refused",
+            negative_prompt=req.negative_prompt,
+            steps=req.steps,
+            guidance_scale=req.guidance_scale,
+            seed=req.seed,
+            aspect_ratio=req.aspect_ratio,
+            device=req.device
+        )
         return {
             "status": "REFUSED",
             "prompt_metadata": mod_res,
@@ -561,51 +596,82 @@ def api_generate(req: GenerateRequest, request: Request):
     
     # 3. Image Generation
     print(f"[API Generate] Generating image (mock={req.mock}, device={req.device})...")
-    # If device matches our pipeline device, use existing pipeline, otherwise initialize
-    local_pipeline = pipeline
-    if req.device != pipeline.device:
-        local_pipeline = LumaForgePipeline(device=req.device)
+    local_pipeline = pipeline_registry.get_pipeline(req.device)
         
-    gen_res = local_pipeline.generate(
-        prompt=gen_prompt,
-        aspect_ratio=req.aspect_ratio,
-        steps=req.steps,
-        seed=req.seed,
-        guidance_scale=req.guidance_scale,
-        negative_prompt=req.negative_prompt,
-        mock=req.mock
-    )
-    
-    # 4. Save locally for record-keeping and post-safety checks
-    os.makedirs("outputs", exist_ok=True)
-    out_path = os.path.join("outputs", f"output_{gen_res['seed']}.png")
-    gen_res["image"].save(out_path, pnginfo=gen_res.get("pnginfo"))
-    
-    # 5. Output Post-generation Screen
-    post_res = safety_manager.check_output_safety(out_path, mod_res)
-    
-    # 6. Convert image to Base64 to return in JSON payload
-    buffered = BytesIO()
-    gen_res["image"].save(buffered, format="PNG", pnginfo=gen_res.get("pnginfo"))
-    img_str = base64.b64encode(buffered.getvalue()).decode("utf-8")
-    image_b64 = f"data:image/png;base64,{img_str}"
-    
-    return {
-        "status": mod_res["status"],
-        "image_b64": image_b64,
-        "prompt_metadata": mod_res,
-        "expanded_prompt": expanded,
-        "generation_metadata": {
-            "latency_sec": gen_res["latency_sec"],
-            "memory_used_mb": gen_res["memory_used_mb"],
-            "seed": gen_res["seed"],
-            "width": gen_res["width"],
-            "height": gen_res["height"],
-            "device": gen_res["device"],
-            "used_mock": gen_res["used_mock"]
-        },
-        "safety_check": post_res
-    }
+    try:
+        gen_res = local_pipeline.generate(
+            prompt=gen_prompt,
+            aspect_ratio=req.aspect_ratio,
+            steps=req.steps,
+            seed=req.seed,
+            guidance_scale=req.guidance_scale,
+            negative_prompt=req.negative_prompt,
+            mock=req.mock
+        )
+        
+        # 4. Save locally for record-keeping and post-safety checks
+        os.makedirs("outputs", exist_ok=True)
+        out_path = os.path.join("outputs", f"output_{gen_res['seed']}.png")
+        gen_res["image"].save(out_path, pnginfo=gen_res.get("pnginfo"))
+        
+        # 5. Output Post-generation Screen
+        post_res = safety_manager.check_output_safety(out_path, mod_res)
+        
+        # 6. Convert image to Base64 to return in JSON payload
+        buffered = BytesIO()
+        gen_res["image"].save(buffered, format="PNG", pnginfo=gen_res.get("pnginfo"))
+        img_str = base64.b64encode(buffered.getvalue()).decode("utf-8")
+        image_b64 = f"data:image/png;base64,{img_str}"
+        
+        # Log successful generation
+        db_manager.log_generation(
+            session_id=f"direct-{uuid.uuid4()}",
+            prompt=req.prompt,
+            status="completed",
+            expanded_prompt=expanded,
+            negative_prompt=req.negative_prompt,
+            steps=req.steps,
+            guidance_scale=req.guidance_scale,
+            seed=gen_res["seed"],
+            aspect_ratio=req.aspect_ratio,
+            device=gen_res["device"],
+            latency_sec=gen_res["latency_sec"],
+            memory_used_mb=gen_res["memory_used_mb"],
+            image_path=out_path
+        )
+        
+        return {
+            "status": mod_res["status"],
+            "image_b64": image_b64,
+            "prompt_metadata": mod_res,
+            "expanded_prompt": expanded,
+            "generation_metadata": {
+                "latency_sec": gen_res["latency_sec"],
+                "memory_used_mb": gen_res["memory_used_mb"],
+                "seed": gen_res["seed"],
+                "width": gen_res["width"],
+                "height": gen_res["height"],
+                "device": gen_res["device"],
+                "used_mock": gen_res["used_mock"]
+            },
+            "safety_check": post_res
+        }
+    except Exception as e:
+        error_msg = str(e)
+        print(f"[API Generate Error] Inference failed: {error_msg}")
+        db_manager.log_generation(
+            session_id=f"direct-failed-{uuid.uuid4()}",
+            prompt=req.prompt,
+            status="error",
+            negative_prompt=req.negative_prompt,
+            steps=req.steps,
+            guidance_scale=req.guidance_scale,
+            seed=req.seed,
+            aspect_ratio=req.aspect_ratio,
+            device=req.device,
+            error_message=error_msg
+        )
+        raise HTTPException(status_code=500, detail=f"Generation failed: {error_msg}")
 
 def decode_base64_image(image_b64: str) -> Image.Image:
     try:
@@ -626,6 +692,18 @@ def api_generate_img2img(req: Img2ImgRequest, request: Request):
     mod_res = safety_manager.moderate_prompt(req.prompt)
     
     if mod_res["status"] == "REFUSED":
+        # Log refusal to database
+        db_manager.log_generation(
+            session_id=f"direct-img2img-refused-{uuid.uuid4()}",
+            prompt=req.prompt,
+            status="refused",
+            negative_prompt=req.negative_prompt,
+            steps=req.steps,
+            guidance_scale=req.guidance_scale,
+            seed=req.seed,
+            aspect_ratio="1:1",
+            device=req.device
+        )
         return {
             "status": "REFUSED",
             "prompt_metadata": mod_res,
@@ -644,54 +722,86 @@ def api_generate_img2img(req: Img2ImgRequest, request: Request):
     
     # 4. Image Generation
     print(f"[API Generate Img2Img] Generating image (mock={req.mock}, device={req.device}, strength={req.strength})...")
-    local_pipeline = pipeline
-    if req.device != pipeline.device:
-        local_pipeline = LumaForgePipeline(device=req.device)
+    local_pipeline = pipeline_registry.get_pipeline(req.device)
         
-    gen_res = local_pipeline.generate_img2img(
-        image=img,
-        prompt=gen_prompt,
-        strength=req.strength,
-        steps=req.steps,
-        seed=req.seed,
-        guidance_scale=req.guidance_scale,
-        negative_prompt=req.negative_prompt,
-        mock=req.mock
-    )
-    
-    # 5. Save locally for record-keeping and post-safety checks
-    os.makedirs("outputs", exist_ok=True)
-    out_path = os.path.join("outputs", f"output_{gen_res['seed']}.png")
-    gen_res["image"].save(out_path, pnginfo=gen_res.get("pnginfo"))
-    
-    # 6. Output Post-generation Screen
-    post_res = safety_manager.check_output_safety(out_path, mod_res)
-    
-    # 7. Convert image to Base64 to return in JSON payload
-    buffered = BytesIO()
-    gen_res["image"].save(buffered, format="PNG", pnginfo=gen_res.get("pnginfo"))
-    img_str = base64.b64encode(buffered.getvalue()).decode("utf-8")
-    image_b64 = f"data:image/png;base64,{img_str}"
-    
-    return {
-        "status": mod_res["status"],
-        "image_b64": image_b64,
-        "prompt_metadata": mod_res,
-        "expanded_prompt": expanded,
-        "generation_metadata": {
-            "latency_sec": gen_res["latency_sec"],
-            "memory_used_mb": gen_res["memory_used_mb"],
-            "seed": gen_res["seed"],
-            "width": gen_res["width"],
-            "height": gen_res["height"],
-            "steps": gen_res["steps"],
-            "guidance_scale": gen_res["guidance_scale"],
-            "strength": gen_res["strength"],
-            "device": gen_res["device"],
-            "used_mock": gen_res["used_mock"]
-        },
-        "safety_check": post_res
-    }
+    try:
+        gen_res = local_pipeline.generate_img2img(
+            image=img,
+            prompt=gen_prompt,
+            strength=req.strength,
+            steps=req.steps,
+            seed=req.seed,
+            guidance_scale=req.guidance_scale,
+            negative_prompt=req.negative_prompt,
+            mock=req.mock
+        )
+        
+        # 5. Save locally for record-keeping and post-safety checks
+        os.makedirs("outputs", exist_ok=True)
+        out_path = os.path.join("outputs", f"output_{gen_res['seed']}.png")
+        gen_res["image"].save(out_path, pnginfo=gen_res.get("pnginfo"))
+        
+        # 6. Output Post-generation Screen
+        post_res = safety_manager.check_output_safety(out_path, mod_res)
+        
+        # 7. Convert image to Base64 to return in JSON payload
+        buffered = BytesIO()
+        gen_res["image"].save(buffered, format="PNG", pnginfo=gen_res.get("pnginfo"))
+        img_str = base64.b64encode(buffered.getvalue()).decode("utf-8")
+        image_b64 = f"data:image/png;base64,{img_str}"
+        
+        # Log successful generation to SQLite
+        db_manager.log_generation(
+            session_id=f"direct-img2img-{uuid.uuid4()}",
+            prompt=req.prompt,
+            status="completed",
+            expanded_prompt=expanded,
+            negative_prompt=req.negative_prompt,
+            steps=req.steps,
+            guidance_scale=req.guidance_scale,
+            seed=gen_res["seed"],
+            aspect_ratio="1:1",
+            device=gen_res["device"],
+            latency_sec=gen_res["latency_sec"],
+            memory_used_mb=gen_res["memory_used_mb"],
+            image_path=out_path
+        )
+        
+        return {
+            "status": mod_res["status"],
+            "image_b64": image_b64,
+            "prompt_metadata": mod_res,
+            "expanded_prompt": expanded,
+            "generation_metadata": {
+                "latency_sec": gen_res["latency_sec"],
+                "memory_used_mb": gen_res["memory_used_mb"],
+                "seed": gen_res["seed"],
+                "width": gen_res["width"],
+                "height": gen_res["height"],
+                "steps": gen_res["steps"],
+                "guidance_scale": gen_res["guidance_scale"],
+                "strength": gen_res["strength"],
+                "device": gen_res["device"],
+                "used_mock": gen_res["used_mock"]
+            },
+            "safety_check": post_res
+        }
+    except Exception as e:
+        error_msg = str(e)
+        print(f"[API Generate Img2Img Error] Inference failed: {error_msg}")
+        db_manager.log_generation(
+            session_id=f"direct-img2img-failed-{uuid.uuid4()}",
+            prompt=req.prompt,
+            status="error",
+            negative_prompt=req.negative_prompt,
+            steps=req.steps,
+            guidance_scale=req.guidance_scale,
+            seed=req.seed,
+            aspect_ratio="1:1",
+            device=req.device,
+            error_message=error_msg
+        )
+        raise HTTPException(status_code=500, detail=f"Img2Img generation failed: {error_msg}")
 
 @app.post("/api/upscale")
 def api_upscale(req: UpscaleRequest, request: Request):
@@ -789,6 +899,12 @@ def api_audit_log(request: Request, limit: int = 20):
     logs = safety_manager.get_audit_logs(limit=limit)
     return {"logs": logs}
 
+@app.get("/api/history")
+def api_history(request: Request, limit: int = 50):
+    api_limiter.check_limit(request)
+    history = db_manager.get_history(limit=limit)
+    return {"history": history}
+
 def run_train_worker(req: TrainRequest):
     trainer = LumaForgeTrainer(device="mps" if req.demo else "cpu")
     trainer.run_training(
@@ -863,10 +979,7 @@ def api_curate(req: CurateRequest, request: Request):
 def api_benchmark(req: BenchmarkRequest, request: Request):
     api_limiter.check_limit(request)
     
-    # Run in a simple separate execution or directly
-    local_pipeline = pipeline
-    if req.device != pipeline.device:
-        local_pipeline = LumaForgePipeline(device=req.device)
+    local_pipeline = pipeline_registry.get_pipeline(req.device)
         
     suite = BenchmarkSuite(local_pipeline, safety_manager)
     report = suite.run(mock=req.mock)
@@ -890,6 +1003,19 @@ def generate_session_worker(session_id: str, req: GenerateSessionRequest):
                 "error": "Safety violation. Prompt contains prohibited material."
             }
             session_manager.update_session(session_id, "error", result, "Safety check failed")
+            
+            # Log refusal to SQLite
+            db_manager.log_generation(
+                session_id=session_id,
+                prompt=req.prompt,
+                status="refused",
+                negative_prompt=req.negative_prompt,
+                steps=req.steps,
+                guidance_scale=req.guidance_scale,
+                seed=req.seed,
+                aspect_ratio=req.aspect_ratio,
+                device=req.device
+            )
             return
         
         final_prompt = mod_res["final_prompt"]
@@ -904,9 +1030,7 @@ def generate_session_worker(session_id: str, req: GenerateSessionRequest):
         
         # 3. Image Generation
         print(f"[Session {session_id}] Generating image (mock={req.mock}, device={req.device})...")
-        local_pipeline = pipeline
-        if req.device != pipeline.device:
-            local_pipeline = LumaForgePipeline(device=req.device)
+        local_pipeline = pipeline_registry.get_pipeline(req.device)
         
         gen_res = local_pipeline.generate(
             prompt=gen_prompt,
@@ -951,31 +1075,57 @@ def generate_session_worker(session_id: str, req: GenerateSessionRequest):
         
         session_manager.update_session(session_id, "completed", result)
         print(f"[Session {session_id}] Generation completed successfully")
+        
+        # Log successful generation to SQLite
+        db_manager.log_generation(
+            session_id=session_id,
+            prompt=req.prompt,
+            status="completed",
+            expanded_prompt=expanded,
+            negative_prompt=req.negative_prompt,
+            steps=req.steps,
+            guidance_scale=req.guidance_scale,
+            seed=gen_res["seed"],
+            aspect_ratio=req.aspect_ratio,
+            device=gen_res["device"],
+            latency_sec=gen_res["latency_sec"],
+            memory_used_mb=gen_res["memory_used_mb"],
+            image_path=out_path
+        )
     except Exception as e:
         error_msg = str(e)
         print(f"[Session {session_id}] Error during generation: {error_msg}")
         session_manager.update_session(session_id, "error", None, error_msg)
+        
+        # Log error to SQLite
+        db_manager.log_generation(
+            session_id=session_id,
+            prompt=req.prompt,
+            status="error",
+            negative_prompt=req.negative_prompt,
+            steps=req.steps,
+            guidance_scale=req.guidance_scale,
+            seed=req.seed,
+            aspect_ratio=req.aspect_ratio,
+            device=req.device,
+            error_message=error_msg
+        )
 
 @app.post("/api/generate-session/start")
 def api_generate_session_start(req: GenerateSessionRequest, request: Request):
-    """Start a new generation session"""
+    """Start a new generation session in the sequential task queue"""
     api_limiter.check_limit(request)
     
     # Create session
     session_id = session_manager.create_session()
     
-    # Start generation in background thread
-    worker_thread = threading.Thread(
-        target=generate_session_worker,
-        args=(session_id, req),
-        daemon=True
-    )
-    worker_thread.start()
+    # Queue generation session in thread pool executor (sequential queue)
+    generation_executor.submit(generate_session_worker, session_id, req)
     
     return {
         "status": "started",
         "session_id": session_id,
-        "message": "Generation session started. Poll /api/generate-session/status for updates."
+        "message": "Generation session queued. Poll /api/generate-session/status for updates."
     }
 
 @app.post("/api/generate-session/status")

lumaforge/database.py

@@ -0,0 +1,103 @@
+import sqlite3
+import json
+import os
+from datetime import datetime
+
+class DatabaseManager:
+    def __init__(self, db_path="lumaforge.db"):
+        self.db_path = db_path
+        self.init_db()
+
+    def _get_connection(self):
+        """Creates a new SQLite database connection."""
+        conn = sqlite3.connect(self.db_path, check_same_thread=False)
+        conn.row_factory = sqlite3.Row
+        return conn
+
+    def init_db(self):
+        """Initializes the database and creates the generations table if it doesn't exist."""
+        query = """
+        CREATE TABLE IF NOT EXISTS generations (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            session_id TEXT UNIQUE,
+            prompt TEXT NOT NULL,
+            expanded_prompt TEXT, -- JSON string
+            negative_prompt TEXT,
+            steps INTEGER,
+            guidance_scale REAL,
+            seed INTEGER,
+            aspect_ratio TEXT,
+            device TEXT,
+            latency_sec REAL,
+            memory_used_mb REAL,
+            status TEXT,          -- 'completed', 'refused', 'error'
+            image_path TEXT,      -- Path to the stored file on disk
+            error_message TEXT,   -- Holds error logs if failed
+            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+        );
+        """
+        conn = self._get_connection()
+        try:
+            with conn:
+                conn.execute(query)
+            print(f"[DatabaseManager] Database initialized at {os.path.abspath(self.db_path)}")
+        finally:
+            conn.close()
+
+    def log_generation(self, session_id: str, prompt: str, status: str,
+                       expanded_prompt: dict = None, negative_prompt: str = None,
+                       steps: int = None, guidance_scale: float = None,
+                       seed: int = -1, aspect_ratio: str = "1:1", device: str = "mps",
+                       latency_sec: float = 0.0, memory_used_mb: float = 0.0,
+                       image_path: str = None, error_message: str = None):
+        """Logs a generation run (success or failure) to the SQLite database."""
+        query = """
+        INSERT OR REPLACE INTO generations (
+            session_id, prompt, expanded_prompt, negative_prompt, steps,
+            guidance_scale, seed, aspect_ratio, device, latency_sec,
+            memory_used_mb, status, image_path, error_message
+        ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?);
+        """
+        
+        # Serialize dict to JSON string
+        expanded_prompt_json = json.dumps(expanded_prompt) if expanded_prompt else None
+        
+        conn = self._get_connection()
+        try:
+            with conn:
+                conn.execute(query, (
+                    session_id, prompt, expanded_prompt_json, negative_prompt, steps,
+                    guidance_scale, seed, aspect_ratio, device, latency_sec,
+                    memory_used_mb, status, image_path, error_message
+                ))
+            print(f"[DatabaseManager] Logged session {session_id} to database (status: {status})")
+        except Exception as e:
+            print(f"[DatabaseManager Error] Failed to log session {session_id}: {e}")
+        finally:
+            conn.close()
+
+    def get_history(self, limit: int = 50) -> list:
+        """Retrieves historical generation logs, returning a list of dicts."""
+        query = "SELECT * FROM generations ORDER BY created_at DESC LIMIT ?;"
+        conn = self._get_connection()
+        try:
+            cursor = conn.cursor()
+            cursor.execute(query, (limit,))
+            rows = cursor.fetchall()
+            
+            history = []
+            for row in rows:
+                item = dict(row)
+                # Deserialize expanded prompt back to dict
+                if item["expanded_prompt"]:
+                    try:
+                        item["expanded_prompt"] = json.loads(item["expanded_prompt"])
+                    except Exception:
+                        pass
+                history.append(item)
+            return history
+        except Exception as e:
+            print(f"[DatabaseManager Error] Failed to retrieve history: {e}")
+            return []
+        finally:
+            conn.close()

lumaforge/pipeline.py

@@ -44,21 +44,25 @@ class LumaForgePipeline:
             )
                 
             print(f"[LumaForgePipeline] ✅ SD 3.5 Medium loaded successfully")
-            print(f"[LumaForgePipeline] Moving pipeline to {self.device}...")
-            self.pipe.to(self.device)
-            # Keep VAE in float16 to match input latents on MPS (prevent c10::Half / float mismatch)
-            # if self.device == "mps":
-            #     print("[LumaForgePipeline] Upcasting VAE decoder to float32 precision for MPS...")
-            #     self.pipe.vae.to(dtype=torch.float32)
-            #     print("[LumaForgePipeline] ✅ VAE upcasted successfully.")
-            
-            print(f"[LumaForgePipeline] ✅ Pipeline successfully moved to {self.device}")
-            
-            # Memory optimization
-            if self.device == "mps":
-                print(f"[LumaForgePipeline] Enabling attention slicing for MPS memory optimization...")
-                self.pipe.enable_attention_slicing()
-                print(f"[LumaForgePipeline] ✅ Attention slicing enabled.")
+            # Memory optimization & Device placement
+            if self.device in ["mps", "cuda"]:
+                try:
+                    print(f"[LumaForgePipeline] Enabling model CPU offloading for {self.device} memory optimization...")
+                    self.pipe.enable_model_cpu_offload(device=self.device)
+                    print(f"[LumaForgePipeline] ✅ Model CPU offloading enabled.")
+                except Exception as e:
+                    print(f"[LumaForgePipeline Warning] Failed to enable CPU offloading: {e}. Falling back to full device load.")
+                    print(f"[LumaForgePipeline] Moving pipeline to {self.device}...")
+                    self.pipe.to(self.device)
+                    print(f"[LumaForgePipeline] ✅ Pipeline successfully moved to {self.device}")
+                    if self.device == "mps":
+                        print(f"[LumaForgePipeline] Enabling attention slicing for MPS memory optimization...")
+                        self.pipe.enable_attention_slicing()
+                        print(f"[LumaForgePipeline] ✅ Attention slicing enabled.")
+            else:
+                print(f"[LumaForgePipeline] Moving pipeline to {self.device}...")
+                self.pipe.to(self.device)
+                print(f"[LumaForgePipeline] ✅ Pipeline successfully moved to {self.device}")
                 
             self.is_loaded = True
             print("[LumaForgePipeline] ✅ SD 3.5 Medium ready for inference!")
@@ -1206,7 +1210,7 @@ class LumaForgePipeline:
                 draw_gradient_text(
                     overlay, (tx, ty), title_text, t_font, spacing=t_spacing,
                     top_color=(255, 255, 255), bottom_color=(235, 235, 240),
-                    shadow_fill=(0, 0, 0, 100), shadow_offset=(1, 1)
+                    shadow_fill=(0, 0, 0, 180), shadow_offset=(2, 2)
                 )
                 
                 # Gold separator line under title
@@ -1230,7 +1234,7 @@ class LumaForgePipeline:
                     s_w = len(sub_text) * 10
                 sx = (width - s_w) // 2
                 sy = ty - int(height * 0.05)
-                draw_spaced_text(draw_overlay, (sx, sy), sub_text, s_font, fill=(212, 175, 55, 220), spacing=4)
+                draw_spaced_text(draw_overlay, (sx, sy), sub_text, s_font, fill=(212, 175, 55, 220), spacing=4, shadow_fill=(0, 0, 0, 160), shadow_offset=(1, 1))
                 
             else:
                 # 3. Cinematic Action Theme (Default)