Enhance image generation and logging features across frontend and backend

- Added verification and logging for generated images in GeneratePage and AdPreview components to improve user feedback and debugging.
- Updated API endpoint to ensure required parameters are always sent for image generation.
- Enhanced image generation logic in the generator service to support parallel processing and improved error handling.

frontend/app/generate/page.tsx

@@ -279,6 +279,13 @@ export default function GeneratePage() {
 
       clearInterval(progressInterval);
 
+      // Verify all images are included
+      if (result.images && result.images.length > 0) {
+        console.log(`✓ Extensive generation completed with ${result.images.length} image(s)`);
+        console.log(`📅 Generated at: ${result.created_at || 'N/A'}`);
+        console.log(`📊 Note: Generate page shows images from the first strategy only. All strategies are saved separately in the database and appear on the Dashboard.`);
+      }
+
       setProgress({
         step: "saving",
         progress: 90,

frontend/components/generation/AdPreview.tsx

@@ -4,7 +4,7 @@ import React, { useState } from "react";
 import { Button } from "@/components/ui/Button";
 import { Download, Copy } from "lucide-react";
 import { downloadImage, copyToClipboard } from "@/lib/utils/export";
-import { getImageUrl, getImageUrlFallback } from "@/lib/utils/formatters";
+import { getImageUrl, getImageUrlFallback, formatRelativeDate } from "@/lib/utils/formatters";
 import { toast } from "react-hot-toast";
 import type { GenerateResponse, MatrixGenerateResponse } from "@/types/api";
 
@@ -15,6 +15,22 @@ interface AdPreviewProps {
 export const AdPreview: React.FC<AdPreviewProps> = ({ ad }) => {
   const [imageErrors, setImageErrors] = useState<Record<number, boolean>>({});
 
+  // Debug: Log image details to verify uniqueness
+  React.useEffect(() => {
+    if (ad.images && ad.images.length > 1) {
+      console.log(`AdPreview: Displaying ${ad.images.length} images`);
+      console.log(`📅 Generation timestamp: ${ad.created_at || 'N/A'}`);
+      ad.images.forEach((img, idx) => {
+        console.log(`  Image ${idx + 1}:`, {
+          filename: img.filename,
+          image_url: img.image_url?.substring(0, 50) + '...',
+          seed: img.seed,
+        });
+      });
+    }
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [ad.id, ad.images?.length, ad.created_at]); // Use stable dependencies: id, length, and timestamp
+
   const handleDownloadImage = async (imageUrl: string | null | undefined, filename: string | null | undefined) => {
     if (!imageUrl && !filename) {
       toast.error("No image URL available");
@@ -55,6 +71,18 @@ export const AdPreview: React.FC<AdPreviewProps> = ({ ad }) => {
       {/* Images */}
       {ad.images && ad.images.length > 0 && (
         <div className="space-y-4">
+          {ad.images.length > 1 && (
+            <div className="flex items-center justify-between">
+              <h3 className="text-sm font-semibold text-gray-700">
+                Images ({ad.images.length})
+              </h3>
+              {ad.created_at && (
+                <span className="text-xs text-gray-500 font-medium">
+                  Generated {formatRelativeDate(ad.created_at)}
+                </span>
+              )}
+            </div>
+          )}
           {ad.images.length === 1 ? (
             // Single image - full width with better styling
             <div className="bg-white rounded-2xl shadow-lg shadow-blue-100/50 overflow-hidden ring-1 ring-blue-100">
@@ -71,6 +99,11 @@ export const AdPreview: React.FC<AdPreviewProps> = ({ ad }) => {
                       className="w-full h-auto"
                       onError={() => handleImageError(0, image)}
                     />
+                    {ad.created_at && (
+                      <div className="absolute top-4 left-4 bg-black/60 backdrop-blur-sm text-white text-xs font-medium px-2 py-1 rounded-md">
+                        {formatRelativeDate(ad.created_at)}
+                      </div>
+                    )}
                     <div className="absolute top-4 right-4 opacity-0 group-hover:opacity-100 transition-opacity">
                       <div className="relative group/btn">
                         <Button
@@ -111,8 +144,11 @@ export const AdPreview: React.FC<AdPreviewProps> = ({ ad }) => {
                 const { primary, fallback } = getImageUrlFallback(image.image_url, image.filename);
                 const imageUrl = imageErrors[index] ? fallback : (primary || fallback);
                 
+                // Use unique key based on filename or URL to prevent duplicate rendering
+                const uniqueKey = image.filename || image.image_url || `image-${index}`;
+                
                 return (
-                  <div key={index} className="bg-white rounded-2xl shadow-lg shadow-blue-100/50 overflow-hidden ring-1 ring-blue-100">
+                  <div key={uniqueKey} className="bg-white rounded-2xl shadow-lg shadow-blue-100/50 overflow-hidden ring-1 ring-blue-100">
                     {imageUrl ? (
                       <div className="relative group">
                         <img
@@ -121,6 +157,10 @@ export const AdPreview: React.FC<AdPreviewProps> = ({ ad }) => {
                           className="w-full h-auto"
                           onError={() => handleImageError(index, image)}
                         />
+                        {/* Image number badge */}
+                        <div className="absolute top-2 left-2 bg-black/60 backdrop-blur-sm text-white text-xs font-bold px-2 py-1 rounded-md">
+                          Image {index + 1}
+                        </div>
                         <div className="absolute top-2 right-2 opacity-0 group-hover:opacity-100 transition-opacity">
                           <div className="relative group/btn">
                             <Button
@@ -152,6 +192,17 @@ export const AdPreview: React.FC<AdPreviewProps> = ({ ad }) => {
                         <p className="text-xs text-red-800">Error: {image.error}</p>
                       </div>
                     )}
+                    {/* Image metadata footer */}
+                    <div className="p-2 bg-gray-50 border-t border-gray-100 flex items-center justify-between text-xs">
+                      <span className="text-gray-500">
+                        {image.seed && `Seed: ${image.seed}`}
+                      </span>
+                      {image.filename && (
+                        <span className="text-gray-400 font-mono text-[10px] truncate max-w-[150px]">
+                          {image.filename.split('_').pop()?.split('.')[0]}
+                        </span>
+                      )}
+                    </div>
                   </div>
                 );
               })}

frontend/lib/api/endpoints.ts

@@ -67,11 +67,20 @@ export const generateExtensiveAd = async (params: {
   niche: Niche;
   target_audience: string;
   offer: string;
-  num_images?: number;
+  num_images: number;
   image_model?: string | null;
-  num_strategies?: number;
+  num_strategies: number;
 }): Promise<GenerateResponse> => {
-  const response = await apiClient.post<GenerateResponse>("/extensive/generate", params);
+  // Ensure required parameters are always sent
+  const requestParams = {
+    niche: params.niche,
+    target_audience: params.target_audience,
+    offer: params.offer,
+    num_images: params.num_images || 1,
+    num_strategies: params.num_strategies || 1,
+    ...(params.image_model && { image_model: params.image_model }),
+  };
+  const response = await apiClient.post<GenerateResponse>("/extensive/generate", requestParams);
   return response.data;
 };
 

services/generator.py

@@ -14,8 +14,10 @@ sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 import random
 import uuid
 import json
+import asyncio
 from datetime import datetime
 from typing import Dict, Any, List, Optional
+from concurrent.futures import ThreadPoolExecutor
 
 from config import settings
 from services.llm import llm_service
@@ -1105,6 +1107,17 @@ NO text overlays, decorative elements, borders, banners, or overlays.
 === VISUAL SCENE ===
 {image_brief}
 
+=== CRITICAL: PEOPLE AND FACES ===
+If this image includes people or faces, they MUST look like real, original people with:
+- Photorealistic faces with natural skin texture, visible pores, and realistic skin imperfections
+- Natural facial asymmetry (no perfectly symmetrical faces)
+- Unique, individual facial features (not generic or model-like)
+- Natural expressions with authentic micro-expressions
+- Realistic skin tones with natural variations and undertones
+- Natural hair texture with individual strands
+- Faces that look like real photographs of real people, NOT AI-generated portraits
+- Avoid any faces that look synthetic, fake, or obviously computer-generated
+
 IMPORTANT: Do NOT display numbers, prices, dollar amounts, or savings figures in the image unless they naturally appear as part of the scene (like on a document someone is holding, or a sign in the background). Focus on the visual scene and people, not numerical information. Numbers should be in the ad copy, not the image.
 
 === VISUAL SPECIFICATIONS ===
@@ -1131,6 +1144,21 @@ PEOPLE (if present):
 - Natural expressions (not posed smiles)
 - Relatable, trustworthy appearance
 
+FACE REQUIREMENTS (CRITICAL - for natural, original-looking faces):
+- Photorealistic faces with natural skin texture and pores
+- Subtle facial asymmetry (real faces are never perfectly symmetrical)
+- Natural skin imperfections: fine lines, freckles, moles, natural variations in skin tone
+- Realistic facial features: unique nose shapes, eye shapes, lip shapes (not generic or perfect)
+- Natural hair texture with individual strands visible, not overly smooth or perfect
+- Authentic expressions with natural micro-expressions and subtle wrinkles around eyes/mouth
+- Realistic lighting on faces showing natural shadows and highlights
+- Natural skin tones with realistic color variations and undertones
+- Avoid overly smooth, plastic-looking skin
+- Avoid perfectly symmetrical faces
+- Avoid generic or "model-like" features
+- Include natural facial hair, age spots, or other authentic characteristics when appropriate
+- Faces should look like real photographs of real people, not AI-generated portraits
+
 SETTINGS (if present):
 - Real locations (homes, yards, offices)
 - Lived-in, not staged
@@ -1152,6 +1180,16 @@ DOCUMENTS (if present):
 - NO missing or garbled text
 - NO brand watermarks
 - NO distorted anatomy
+- NO AI-generated faces, synthetic faces, or fake-looking faces
+- NO overly smooth or plastic-looking skin
+- NO perfectly symmetrical faces
+- NO generic or model-like facial features
+- NO uncanny valley faces
+- NO faces that look like they came from a face generator
+- NO overly perfect, flawless skin
+- NO cartoon-like or stylized faces
+- NO faces with unnatural smoothness or lack of texture
+- NO faces that look like stock photos or professional headshots
 - NO decorative borders, frames, or boxes around the image
 - NO banners, badges, or logos in corners (like "BREAKING", "TRUSTED", etc.)
 - NO overlay boxes or rectangular overlays with text
@@ -1413,10 +1451,9 @@ CRITICAL REQUIREMENTS:
             temperature=0.95,  # High for variety
         )
         
-        # Generate image(s) with professional prompt
-        generated_images = []
-        
-        for i in range(num_images):
+        # Generate image(s) with professional prompt - PARALLELIZED
+        async def generate_single_image(image_index: int):
+            """Helper function to generate a single image with all processing."""
             # Build image prompt with all parameters
             image_prompt = self._build_image_prompt(
                 niche=niche,
@@ -1430,13 +1467,14 @@ CRITICAL REQUIREMENTS:
                 niche_visual_guidance_data=niche_visual_guidance_data,
             )
             
-            # Store the refined prompt for database saving (this is the final prompt sent to image service)
+            # Store the refined prompt for database saving
             refined_image_prompt = image_prompt
             
             # Generate with random seed
             seed = random.randint(1, 2147483647)
             
             try:
+                # Generate image (async)
                 image_bytes, model_used, image_url = await image_service.generate(
                     prompt=image_prompt,
                     width=settings.image_width,
@@ -1448,40 +1486,25 @@ CRITICAL REQUIREMENTS:
                 # Generate filename
                 timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
                 unique_id = str(uuid.uuid4())[:8]
-                filename = f"{niche}_{timestamp}_{unique_id}.png"
-                
-                # Upload to R2 if available, otherwise save locally
-                r2_url = None
-                if r2_storage_available:
-                    try:
-                        r2_storage = get_r2_storage()
-                        if r2_storage:
-                            r2_url = r2_storage.upload_image(
-                                image_bytes=image_bytes,
-                                filename=filename,
-                                niche=niche,
-                            )
-                            print(f"Image uploaded to R2: {r2_url}")
-                    except Exception as e:
-                        print(f"Warning: Failed to upload to R2: {e}. Saving locally as backup.")
-                
-                # Generate filename
-                timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-                unique_id = str(uuid.uuid4())[:8]
-                filename = f"{niche}_{timestamp}_{unique_id}.png"
+                filename = f"{niche}_{timestamp}_{unique_id}_{image_index}.png"
                 
-                # Upload to R2 if available, otherwise save locally
+                # Upload to R2 in parallel thread (sync operation)
                 r2_url = None
                 if r2_storage_available:
                     try:
                         r2_storage = get_r2_storage()
                         if r2_storage:
-                            r2_url = r2_storage.upload_image(
-                                image_bytes=image_bytes,
-                                filename=filename,
-                                niche=niche,
+                            # Run R2 upload in thread pool (sync operation)
+                            loop = asyncio.get_event_loop()
+                            r2_url = await loop.run_in_executor(
+                                None,
+                                lambda: r2_storage.upload_image(
+                                    image_bytes=image_bytes,
+                                    filename=filename,
+                                    niche=niche,
+                                )
                             )
-                            print(f"Image uploaded to R2: {r2_url}")
+                            print(f"Image {image_index + 1} uploaded to R2: {r2_url}")
                     except Exception as e:
                         print(f"Warning: Failed to upload to R2: {e}. Saving locally as backup.")
                 
@@ -1491,22 +1514,31 @@ CRITICAL REQUIREMENTS:
                 # Use R2 URL if available, otherwise use Replicate URL, fallback to local
                 final_image_url = r2_url or image_url
                 
-                generated_images.append({
+                return {
                     "filename": filename,
                     "filepath": filepath,
-                    "image_url": final_image_url,  # R2 URL (preferred) or Replicate URL
-                    "r2_url": r2_url,  # R2 URL if uploaded
+                    "image_url": final_image_url,
+                    "r2_url": r2_url,
                     "model_used": model_used,
                     "seed": seed,
-                    "image_prompt": refined_image_prompt,  # Store the final prompt
-                })
+                    "image_prompt": refined_image_prompt,
+                }
                 
             except Exception as e:
-                generated_images.append({
+                return {
                     "error": str(e),
                     "seed": seed,
-                    "image_prompt": refined_image_prompt if 'refined_image_prompt' in locals() else None,
-                })
+                    "image_prompt": refined_image_prompt,
+                }
+        
+        # Generate all images in parallel using asyncio.gather
+        if num_images > 1:
+            print(f"🔄 Generating {num_images} images in parallel...")
+            image_tasks = [generate_single_image(i) for i in range(num_images)]
+            generated_images = await asyncio.gather(*image_tasks)
+        else:
+            # Single image - no need for parallelization
+            generated_images = [await generate_single_image(0)]
         
         # Generate unique ID
         ad_id = str(uuid.uuid4())
@@ -1693,12 +1725,13 @@ CONCEPT: {concept['name']}
         # Store the refined prompt for database saving (this is the final prompt sent to image service)
         refined_image_prompt = image_prompt
         
-        # Generate images
-        images = []
-        for i in range(num_images):
+        # Generate images - PARALLELIZED
+        async def generate_single_matrix_image(image_index: int):
+            """Helper function to generate a single matrix image with all processing."""
             seed = random.randint(1, 2**31 - 1)
             
             try:
+                # Generate image (async)
                 image_bytes, model_used, image_url = await image_service.generate(
                     prompt=image_prompt,
                     model_key=image_model or settings.image_model,
@@ -1710,20 +1743,25 @@ CONCEPT: {concept['name']}
                 # Generate filename
                 timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
                 unique_id = uuid.uuid4().hex[:8]
-                filename = f"{niche}_{timestamp}_{unique_id}.png"
+                filename = f"{niche}_{timestamp}_{unique_id}_{image_index}.png"
                 
-                # Upload to R2 if available
+                # Upload to R2 in parallel thread (sync operation)
                 r2_url = None
                 if r2_storage_available:
                     try:
                         r2_storage = get_r2_storage()
                         if r2_storage:
-                            r2_url = r2_storage.upload_image(
-                                image_bytes=image_bytes,
-                                filename=filename,
-                                niche=niche,
+                            # Run R2 upload in thread pool (sync operation)
+                            loop = asyncio.get_event_loop()
+                            r2_url = await loop.run_in_executor(
+                                None,
+                                lambda: r2_storage.upload_image(
+                                    image_bytes=image_bytes,
+                                    filename=filename,
+                                    niche=niche,
+                                )
                             )
-                            print(f"Image uploaded to R2: {r2_url}")
+                            print(f"Matrix image {image_index + 1} uploaded to R2: {r2_url}")
                     except Exception as e:
                         print(f"Warning: Failed to upload to R2: {e}. Saving locally as backup.")
                 
@@ -1733,18 +1771,18 @@ CONCEPT: {concept['name']}
                 # Use R2 URL if available, otherwise use Replicate URL
                 final_image_url = r2_url or image_url
                 
-                images.append({
+                return {
                     "filename": filename,
                     "filepath": filepath,
-                    "image_url": final_image_url,  # R2 URL (preferred) or Replicate URL
-                    "r2_url": r2_url,  # R2 URL if uploaded
+                    "image_url": final_image_url,
+                    "r2_url": r2_url,
                     "model_used": model_used,
                     "seed": seed,
-                    "image_prompt": refined_image_prompt,  # Store the final prompt
+                    "image_prompt": refined_image_prompt,
                     "error": None,
-                })
+                }
             except Exception as e:
-                images.append({
+                return {
                     "filename": None,
                     "filepath": None,
                     "image_url": None,
@@ -1752,7 +1790,16 @@ CONCEPT: {concept['name']}
                     "seed": seed,
                     "image_prompt": refined_image_prompt if 'refined_image_prompt' in locals() else None,
                     "error": str(e),
-                })
+                }
+        
+        # Generate all images in parallel using asyncio.gather
+        if num_images > 1:
+            print(f"🔄 Generating {num_images} matrix images in parallel...")
+            image_tasks = [generate_single_matrix_image(i) for i in range(num_images)]
+            images = await asyncio.gather(*image_tasks)
+        else:
+            # Single image - no need for parallelization
+            images = [await generate_single_matrix_image(0)]
         
         # Generate unique ID
         ad_id = str(uuid.uuid4())
@@ -1898,7 +1945,8 @@ CONCEPT: {concept['name']}
             ads_knowledge = ads_future.result()
         
         # Step 3: Creative Director
-        print("🎨 Step 3: Creating creative strategies...")
+        print(f"🎨 Step 3: Creating {num_strategies} creative strategy/strategies...")
+        print(f"📋 Parameters: num_strategies={num_strategies}, num_images={num_images}")
         creative_strategies = third_flow_service.creative_director(
             researcher_output=researcher_output,
             book_knowledge=book_knowledge,
@@ -1912,6 +1960,10 @@ CONCEPT: {concept['name']}
         if not creative_strategies:
             raise ValueError("Creative director returned no strategies")
         
+        # Limit to requested number of strategies (in case LLM returns more)
+        creative_strategies = creative_strategies[:num_strategies]
+        print(f"📊 Using {len(creative_strategies)} strategy/strategies (requested: {num_strategies})")
+        
         # Step 4: Process strategies in parallel (designer + copywriter)
         print(f"⚡ Step 4: Processing {len(creative_strategies)} strategies in parallel...")
         from concurrent.futures import ThreadPoolExecutor as TPE
@@ -1923,51 +1975,81 @@ CONCEPT: {concept['name']}
             ))
         
         # Step 5: Generate images for each strategy
-        print(f"🖼️  Step 5: Generating images...")
+        # Ensure we only process the requested number of strategies
+        strategies_to_process = min(len(strategy_results), num_strategies)
+        print(f"🖼️  Step 5: Generating {num_images} image(s) per strategy for {strategies_to_process} strategy/strategies...")
         all_results = []
         
-        for idx, (prompt, title, body, description) in enumerate(strategy_results):
+        for idx, (prompt, title, body, description) in enumerate(strategy_results[:strategies_to_process]):
+            if idx >= num_strategies:
+                print(f"⚠️  Stopping at strategy {idx + 1} (requested {num_strategies} strategies)")
+                break
+                
             if not prompt:
                 print(f"Warning: Strategy {idx + 1} has no prompt, skipping...")
                 continue
             
-            # Generate images for this strategy
-            generated_images = []
-            for img_idx in range(num_images):
+            # Generate images for this strategy (respecting num_images parameter) - PARALLELIZED
+            print(f"  Generating {num_images} image(s) for strategy {idx + 1}/{len(creative_strategies)}...")
+            
+            # Variation modifiers to ensure different images
+            variation_modifiers = [
+                "different camera angle, unique composition",
+                "alternative perspective, varied lighting",
+                "distinct framing, different visual style",
+                "unique viewpoint, varied composition",
+                "alternative angle, different mood",
+            ]
+            
+            async def generate_single_extensive_image(img_idx: int):
+                """Helper function to generate a single extensive image with all processing."""
                 try:
-                    # Refine prompt
-                    refined_prompt = self._refine_image_prompt(prompt)
+                    # Refine prompt and add variation for each image
+                    base_refined_prompt = self._refine_image_prompt(prompt)
+                    
+                    # Add variation modifier if generating multiple images
+                    if num_images > 1:
+                        variation = variation_modifiers[img_idx % len(variation_modifiers)]
+                        refined_prompt = f"{base_refined_prompt}, {variation}"
+                    else:
+                        refined_prompt = base_refined_prompt
                     
-                    # Generate image
+                    # Generate unique seed for each image
+                    actual_seed = random.randint(1, 2147483647)
+                    
+                    # Generate image (async)
                     image_bytes, model_used, image_url = await image_service.generate(
                         prompt=refined_prompt,
-                        seed=random.randint(1, 2147483647),
+                        seed=actual_seed,
                         model_key=image_model,
                     )
                     
                     if not image_bytes:
                         print(f"Warning: Failed to generate image {img_idx + 1} for strategy {idx + 1}")
-                        # Add error entry instead of silently skipping
-                        generated_images.append({
+                        return {
                             "error": "Image generation returned no image data",
-                            "seed": random.randint(1, 2147483647),
+                            "seed": actual_seed,
                             "image_prompt": refined_prompt,
-                        })
-                        continue
+                        }
                     
-                    # Generate filename
-                    filename = f"{niche}_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{uuid.uuid4().hex[:8]}.png"
+                    # Generate filename with unique identifier
+                    filename = f"{niche}_{datetime.now().strftime('%Y%m%d_%H%M%S')}_{uuid.uuid4().hex[:8]}_{img_idx}.png"
                     
-                    # Upload to R2 if available
+                    # Upload to R2 in parallel thread (sync operation)
                     r2_url = None
                     if r2_storage_available:
                         try:
                             r2_storage = get_r2_storage()
                             if r2_storage:
-                                r2_url = r2_storage.upload_image(
-                                    image_bytes, filename=filename, niche=niche
+                                # Run R2 upload in thread pool (sync operation)
+                                loop = asyncio.get_event_loop()
+                                r2_url = await loop.run_in_executor(
+                                    None,
+                                    lambda: r2_storage.upload_image(
+                                        image_bytes, filename=filename, niche=niche
+                                    )
                                 )
-                                print(f"Image uploaded to R2: {r2_url}")
+                                print(f"Extensive image {img_idx + 1} uploaded to R2: {r2_url}")
                         except Exception as r2_e:
                             print(f"Warning: Failed to upload image to R2: {r2_e}")
                     
@@ -1977,25 +2059,34 @@ CONCEPT: {concept['name']}
                     # Use R2 URL if available, otherwise use Replicate URL
                     final_image_url = r2_url or image_url
                     
-                    # Always add image entry (frontend can use filename for local images)
-                    # If we have image_bytes, we saved it locally, so filename is available
-                    generated_images.append({
+                    result = {
                         "filename": filename,
                         "filepath": filepath,
-                        "image_url": final_image_url,  # May be None if R2 and Replicate both failed, but filename will work
+                        "image_url": final_image_url,
                         "r2_url": r2_url,
                         "model_used": model_used,
-                        "seed": random.randint(1, 2147483647),
+                        "seed": actual_seed,
                         "image_prompt": refined_prompt,
-                    })
+                    }
+                    print(f"    ✓ Image {img_idx + 1}/{num_images} generated with seed {actual_seed}")
+                    return result
                 except Exception as e:
                     print(f"Error generating image {img_idx + 1} for strategy {idx + 1}: {e}")
-                    # Add error entry instead of silently skipping (like standard flow)
-                    generated_images.append({
+                    error_seed = random.randint(1, 2147483647)
+                    return {
                         "error": str(e),
-                        "seed": random.randint(1, 2147483647),
+                        "seed": error_seed,
                         "image_prompt": refined_prompt if 'refined_prompt' in locals() else None,
-                    })
+                    }
+            
+            # Generate all images in parallel using asyncio.gather
+            if num_images > 1:
+                print(f"    🔄 Generating {num_images} images in parallel for strategy {idx + 1}...")
+                image_tasks = [generate_single_extensive_image(img_idx) for img_idx in range(num_images)]
+                generated_images = await asyncio.gather(*image_tasks)
+            else:
+                # Single image - no need for parallelization
+                generated_images = [await generate_single_extensive_image(0)]
             
             if not generated_images:
                 print(f"Warning: No images generated for strategy {idx + 1}, skipping...")
@@ -2062,7 +2153,7 @@ CONCEPT: {concept['name']}
                 "cta": cta,
                 "psychological_angle": strategy.phsychologyTrigger or "",
                 "why_it_works": f"Angle: {strategy.angle}, Concept: {strategy.concept}",
-                "images": generated_images,
+                "images": generated_images,  # Include ALL images for this strategy
                 "metadata": {
                     "strategies_used": [strategy.phsychologyTrigger] if strategy.phsychologyTrigger else ["extensive"],
                     "creative_direction": f"Extensive: {strategy.angle} × {strategy.concept}",
@@ -2075,10 +2166,13 @@ CONCEPT: {concept['name']}
                     "visual_styles": [strategy.concept] if strategy.concept else [],
                 },
             })
+            print(f"✓ Strategy {idx + 1} completed with {len(generated_images)} image(s)")
         
         # Return first result (or all if needed)
         if all_results:
-            return all_results[0]  # Return first strategy result
+            result = all_results[0]
+            print(f"📤 Returning result with {len(result.get('images', []))} image(s)")
+            return result  # Return first strategy result with all its images
         else:
             raise ValueError("No ads generated from extensive")
     
@@ -2216,6 +2310,17 @@ This image should trigger: {angle.get('trigger')}
 
 {niche_guidance}
 
+=== CRITICAL: PEOPLE AND FACES ===
+If this image includes people or faces, they MUST look like real, original people with:
+- Photorealistic faces with natural skin texture, visible pores, and realistic skin imperfections
+- Natural facial asymmetry (no perfectly symmetrical faces)
+- Unique, individual facial features (not generic or model-like)
+- Natural expressions with authentic micro-expressions
+- Realistic skin tones with natural variations and undertones
+- Natural hair texture with individual strands
+- Faces that look like real photographs of real people, NOT AI-generated portraits
+- Avoid any faces that look synthetic, fake, or obviously computer-generated
+
 === LAYOUT ===
 - Text zone (bottom 25%): "{headline}"
 - Visual zone (top 75%): Scene following {concept.get('name')} concept
@@ -2226,6 +2331,14 @@ This image should trigger: {angle.get('trigger')}
 - Text that is too small to read
 - Generic stock photo look
 - Watermarks, logos
+- AI-generated faces, synthetic faces, or fake-looking faces
+- Overly smooth or plastic-looking skin
+- Perfectly symmetrical faces
+- Generic or model-like facial features
+- Uncanny valley faces
+- Faces that look like they came from a face generator
+- Overly perfect, flawless skin
+- Cartoon-like or stylized faces
 
 Create a scroll-stopping ad image with "{headline}" prominently displayed."""
         
@@ -2242,8 +2355,9 @@ Create a scroll-stopping ad image with "{headline}" prominently displayed."""
         username: Optional[str] = None,  # Username of the user generating the ads
     ) -> List[Dict[str, Any]]:
         """
-        Generate multiple ad creatives.
+        Generate multiple ad creatives - PARALLELIZED.
         Uses variety: 50% standard generation, 50% matrix generation.
+        Uses semaphore to limit concurrent operations and prevent resource exhaustion.
         
         Args:
             niche: Target niche
@@ -2253,55 +2367,63 @@ Create a scroll-stopping ad image with "{headline}" prominently displayed."""
         Returns:
             List of ad results (all normalized to GenerateResponse format)
         """
-        results = []
+        # Use semaphore to limit concurrent ad generation (max 3 at a time to avoid overwhelming APIs)
+        semaphore = asyncio.Semaphore(3)
         
-        for i in range(count):
-            try:
-                # Use variety: 50% standard, 50% matrix (ensures all resources used)
-                use_matrix = random.random() < 0.5  # 50% chance to use matrix
-                
-                if use_matrix:
-                    # Use angle × concept matrix approach
-                    result = await self.generate_ad_with_matrix(
-                        niche=niche,
-                        num_images=images_per_ad,
-                        image_model=image_model,
-                        username=username,  # Pass username
-                    )
-                    # Normalize matrix result to standard format for batch response
-                    # Extract matrix info and convert metadata
-                    matrix_info = result.get("matrix", {})
-                    angle = matrix_info.get("angle", {})
-                    concept = matrix_info.get("concept", {})
+        async def generate_single_ad(ad_index: int):
+            """Helper function to generate a single ad with semaphore control."""
+            async with semaphore:
+                try:
+                    # Use variety: 50% standard, 50% matrix (ensures all resources used)
+                    use_matrix = random.random() < 0.5  # 50% chance to use matrix
                     
-                    # Convert to standard AdMetadata format
-                    result["metadata"] = {
-                        "strategies_used": [angle.get("trigger", "emotional_trigger")],
-                        "creative_direction": f"Angle: {angle.get('name', '')}, Concept: {concept.get('name', '')}",
-                        "visual_mood": concept.get("visual", "").split(".")[0] if concept.get("visual") else "authentic",
-                        "framework": None,
-                        "camera_angle": None,
-                        "lighting": None,
-                        "composition": None,
-                        "hooks_inspiration": [angle.get("example", "")] if angle.get("example") else [],
-                        "visual_styles": [concept.get("structure", "")] if concept.get("structure") else [],
+                    if use_matrix:
+                        # Use angle × concept matrix approach
+                        result = await self.generate_ad_with_matrix(
+                            niche=niche,
+                            num_images=images_per_ad,
+                            image_model=image_model,
+                            username=username,  # Pass username
+                        )
+                        # Normalize matrix result to standard format for batch response
+                        # Extract matrix info and convert metadata
+                        matrix_info = result.get("matrix", {})
+                        angle = matrix_info.get("angle", {})
+                        concept = matrix_info.get("concept", {})
+                        
+                        # Convert to standard AdMetadata format
+                        result["metadata"] = {
+                            "strategies_used": [angle.get("trigger", "emotional_trigger")],
+                            "creative_direction": f"Angle: {angle.get('name', '')}, Concept: {concept.get('name', '')}",
+                            "visual_mood": concept.get("visual", "").split(".")[0] if concept.get("visual") else "authentic",
+                            "framework": None,
+                            "camera_angle": None,
+                            "lighting": None,
+                            "composition": None,
+                            "hooks_inspiration": [angle.get("example", "")] if angle.get("example") else [],
+                            "visual_styles": [concept.get("structure", "")] if concept.get("structure") else [],
+                        }
+                        # Remove matrix field as it's not in GenerateResponse
+                        result.pop("matrix", None)
+                    else:
+                        # Use standard framework-based approach
+                        result = await self.generate_ad(
+                            niche=niche,
+                            num_images=images_per_ad,
+                            image_model=image_model,
+                            username=username,  # Pass username
+                        )
+                    return result
+                except Exception as e:
+                    return {
+                        "error": str(e),
+                        "index": ad_index,
                     }
-                    # Remove matrix field as it's not in GenerateResponse
-                    result.pop("matrix", None)
-                else:
-                    # Use standard framework-based approach
-                    result = await self.generate_ad(
-                        niche=niche,
-                        num_images=images_per_ad,
-                        image_model=image_model,
-                        username=username,  # Pass username
-                    )
-                results.append(result)
-            except Exception as e:
-                results.append({
-                    "error": str(e),
-                    "index": i,
-                })
+        
+        # Generate all ads in parallel using asyncio.gather with semaphore control
+        print(f"🔄 Generating {count} ads in parallel (max 3 concurrent)...")
+        ad_tasks = [generate_single_ad(i) for i in range(count)]
+        results = await asyncio.gather(*ad_tasks)
         
         return results
 

services/third_flow.py

@@ -476,7 +476,18 @@ class ThirdFlowService:
                         Affiliate marketing is a performance-based model where you promote someone else's product or service and earn a commission for each qualified action (click, lead, or sale).
                         In affiliate marketing 'Low-production, realistic images often outperform studio creatives' runs most.
                         
-                        For nano banana image model here's structure for the prompt: [The Hook] + [The Subject] + [The Context/Setting] + [The Technical Polish]"""
+                        For nano banana image model here's structure for the prompt: [The Hook] + [The Subject] + [The Context/Setting] + [The Technical Polish]
+                        
+                        CRITICAL: If the image includes people or faces, ensure they look like real, original people with:
+                        - Photorealistic faces with natural skin texture, visible pores, and realistic skin imperfections
+                        - Natural facial asymmetry (no perfectly symmetrical faces)
+                        - Unique, individual facial features (not generic or model-like)
+                        - Natural expressions with authentic micro-expressions
+                        - Realistic skin tones with natural variations
+                        - Faces that look like real photographs of real people, NOT AI-generated portraits
+                        - Avoid any faces that look synthetic, fake, or obviously computer-generated
+                        - Avoid overly smooth or plastic-looking skin
+                        - Avoid perfectly symmetrical faces or generic model-like features"""
                     }
                 ]
             },