Implement image regeneration feature and update API endpoints

- Added a new API endpoint for regenerating images, allowing users to create new versions of existing ads with optional model selection.
- Introduced a frontend modal for image regeneration, enhancing user interaction and experience.
- Updated the API to list available image generation models, providing users with options for customization.
- Refactored data models and types to support the new regeneration functionality, ensuring type safety and consistency across the application.
- Enhanced the concepts framework by moving visual structure layouts to a separate file for better organization and clarity.

data/concepts.py

@@ -10,8 +10,9 @@ import random
 
 
 class ConceptCategory(str, Enum):
-    """Concept categories."""
-    VISUAL_STRUCTURE = "visual_structure"
+    """Concept categories - focused on creative HOW (storytelling, proof, etc.)
+    Note: Visual layouts (before/after, split screen, etc.) are now in visuals.py
+    """
     UGC_NATIVE = "ugc_native"
     STORYTELLING = "storytelling"
     COMPARISON = "comparison"
@@ -23,26 +24,9 @@ class ConceptCategory(str, Enum):
     CTA_FOCUSED = "cta_focused"
 
 
-# Complete concepts framework - 100 concepts (10 per category)
+# Complete concepts framework - focused on creative HOW (not visual layouts)
+# Note: Visual structure layouts (before/after, split screen, etc.) moved to visuals.py
 CONCEPTS = {
-    ConceptCategory.VISUAL_STRUCTURE: {
-        "name": "Visual Structure",
-        "concepts": [
-            {"key": "before_after", "name": "Before vs After", "structure": "Left=pain, Right=solution", "visual": "Split-screen transformation"},
-            {"key": "split_screen", "name": "Split Screen", "structure": "Two halves comparison", "visual": "Vertical or horizontal split"},
-            {"key": "checklist", "name": "Checklist / Tick Marks", "structure": "List with checkmarks", "visual": "Clean list, prominent checks"},
-            {"key": "bold_headline", "name": "Bold Headline Image", "structure": "Headline dominates", "visual": "Large bold typography"},
-            {"key": "text_first", "name": "Text-First Image", "structure": "Text primary, image secondary", "visual": "Clear typography hierarchy"},
-            {"key": "minimalist", "name": "Minimalist Design", "structure": "White space, minimal elements", "visual": "Clean lines, focused"},
-            {"key": "big_numbers", "name": "Big Numbers Visual", "structure": "Numbers dominate", "visual": "Huge numbers, bold type"},
-            {"key": "highlight_circle", "name": "Highlight / Circle Focus", "structure": "Circle on key element", "visual": "Red circles, arrows"},
-            {"key": "step_by_step", "name": "Step-by-Step Visual", "structure": "Step 1 → 2 → 3", "visual": "Clear flow, numbered"},
-            {"key": "icon_based", "name": "Icon-Based Layout", "structure": "Icons represent features", "visual": "Clear icons, organized"},
-            {"key": "grid_layout", "name": "Grid Layout", "structure": "Organized grid format", "visual": "Clean grid, easy to scan"},
-            {"key": "timeline_visual", "name": "Timeline Visual", "structure": "Time-based progression", "visual": "Clear timeline flow"},
-            {"key": "infographic_style", "name": "Infographic Style", "structure": "Information graphics", "visual": "Data visualization"},
-        ]
-    },
     ConceptCategory.UGC_NATIVE: {
         "name": "UGC & Native",
         "concepts": [
@@ -132,7 +116,6 @@ CONCEPTS = {
         "name": "Scroll-Stopping",
         "concepts": [
             {"key": "shock_headline", "name": "Shock Headline", "structure": "Shocking headline dominates", "visual": "Bold, high contrast"},
-            {"key": "red_warning", "name": "Big Red Warning Text", "structure": "Red warning prominent", "visual": "Large red text"},
             {"key": "unusual_contrast", "name": "Unusual Contrast", "structure": "High contrast, unusual colors", "visual": "Stands out"},
             {"key": "pattern_break", "name": "Pattern Break Design", "structure": "Different from expected", "visual": "Unexpected"},
             {"key": "unexpected_image", "name": "Unexpected Image", "structure": "Surprising visual", "visual": "Attention-grabbing"},
@@ -250,8 +233,8 @@ def get_random_concepts(count: int = 5, diverse: bool = True) -> List[Dict[str,
 
 # Top performing concepts for initial testing
 TOP_CONCEPTS = [
-    "before_after", "selfie_style", "problem_awareness",
-    "side_by_side_table", "relatable_moment"
+    "selfie_style", "problem_awareness", "side_by_side_table", 
+    "relatable_moment", "testimonial_screenshot"
 ]
 
 
@@ -261,17 +244,19 @@ def get_top_concepts() -> List[Dict[str, Any]]:
 
 
 def get_compatible_concepts(angle_trigger: str) -> List[Dict[str, Any]]:
-    """Get concepts compatible with a psychological trigger."""
-    # Compatibility mapping
+    """Get concepts compatible with a psychological trigger.
+    Note: Visual layouts (before_after, split_screen, etc.) are now in visuals.py
+    """
+    # Compatibility mapping - concepts only (not visual layouts)
     compatibility = {
-        "Fear": ["before_after", "shock_headline", "red_warning", "problem_awareness"],
-        "Relief": ["before_after", "relief_moment", "success_moment", "turning_point"],
-        "Greed": ["big_numbers", "price_stack", "value_breakdown", "side_by_side_table"],
-        "FOMO": ["countdown_cta", "red_warning", "crowd", "trending"],
-        "Social Proof": ["testimonial_screenshot", "review_stars", "real_customer", "crowd"],
+        "Fear": ["shock_headline", "problem_awareness", "micro_story", "visual_tension"],
+        "Relief": ["relief_moment", "success_moment", "turning_point", "emotional_snapshot"],
+        "Greed": ["price_stack", "value_breakdown", "side_by_side_table", "ranking"],
+        "FOMO": ["countdown_cta", "crowd", "community", "urgent"],
+        "Social Proof": ["testimonial_screenshot", "real_customer", "crowd", "ugc_collage"],
         "Authority": ["expert_portrait", "badge_seal", "data_backed", "certification"],
         "Curiosity": ["shock_headline", "unexpected_image", "pattern_break", "bold_claim"],
-        "Pride": ["success_moment", "before_after", "winner_highlight"],
+        "Pride": ["success_moment", "winner_highlight", "milestone_moment"],
         "Convenience": ["three_step", "how_it_works", "simple_explainer"],
         "Trust": ["trust_signals", "badge_seal", "real_customer", "testimonial_screenshot"],
     }

data/glp1.py

@@ -191,7 +191,7 @@ STRATEGIES = {
         ],
         "visual_styles": [
             "relatable person matching demographic, candid shot",
-            "real woman 40-60 in transformation moment",
+            "real woman 25-45 in transformation moment",
             "busy mom in everyday setting, authentic",
             "person in regular clothes, not fitness model",
             "testimonial portrait, trustworthy face",
@@ -424,7 +424,7 @@ STRATEGIES = {
         "visual_styles": [
             "parent with children, health focus",
             "family moments, active lifestyle",
-            "grandparent playing with grandkids",
+            "parent playing with children",
             "health warning, medical imagery",
             "funeral aesthetic, mortality reminder",
             "empty chair at family gathering",
@@ -793,7 +793,7 @@ SUPERIORITY_WINNING_VISUALS = [
 CARE_PROTECTION_LOVED_ONES_VISUALS = [
     "parent with children, wanting to stay healthy for them",
     "person motivated by family love and responsibility",
-    "elderly relative looking proud of health improvements",
+    "family member looking proud of health improvements",
     "family gathering, person wanting to be present",
     "person thinking about being there for grandchildren",
     "family photo showing importance of being healthy",

data/visuals.py

@@ -64,6 +64,25 @@ COMPOSITIONS: List[str] = [
     "foreground/background separation", "depth of field focus", "repetitive patterns", "contrasting elements",
 ]
 
+# Visual Layouts/Formats - How content is structured in the image
+VISUAL_LAYOUTS: List[Dict[str, Any]] = [
+    {"key": "before_after", "name": "Before vs After", "prompt_guidance": "Split-screen transformation, left side shows problem/pain state, right side shows solution/improved state"},
+    {"key": "split_screen", "name": "Split Screen", "prompt_guidance": "Two halves comparison, vertical or horizontal split dividing the image"},
+    {"key": "checklist", "name": "Checklist Layout", "prompt_guidance": "List format with checkmarks, clean organized list with prominent check marks"},
+    {"key": "bold_headline", "name": "Bold Headline", "prompt_guidance": "Large bold typography dominates the image, headline is the primary visual element"},
+    {"key": "text_first", "name": "Text-First", "prompt_guidance": "Text is primary element, image secondary, clear typography hierarchy"},
+    {"key": "minimalist", "name": "Minimalist", "prompt_guidance": "Abundant white space, minimal elements, clean lines, focused composition"},
+    {"key": "big_numbers", "name": "Big Numbers", "prompt_guidance": "Large numbers dominate the visual, huge bold typography for statistics or prices"},
+    {"key": "highlight_circle", "name": "Highlight Circle", "prompt_guidance": "Red circle or arrow highlighting key element, drawing attention to specific area"},
+    {"key": "step_by_step", "name": "Step-by-Step", "prompt_guidance": "Numbered steps flow (1→2→3), clear visual progression"},
+    {"key": "grid_layout", "name": "Grid Layout", "prompt_guidance": "Organized grid format, easy to scan, multiple elements arranged systematically"},
+    {"key": "timeline", "name": "Timeline", "prompt_guidance": "Time-based progression, clear timeline flow showing sequence of events"},
+    {"key": "infographic", "name": "Infographic", "prompt_guidance": "Information graphics, data visualization, charts and visual data representation"},
+    {"key": "comparison_table", "name": "Comparison Table", "prompt_guidance": "Side-by-side table format with checkmarks and crosses for comparison"},
+    {"key": "quote_card", "name": "Quote Card", "prompt_guidance": "Quote as main visual element, clear readable testimonial or statement"},
+    {"key": "screenshot_style", "name": "Screenshot Style", "prompt_guidance": "Device screenshot format, realistic phone or computer interface"},
+]
+
 VISUAL_MOODS: List[str] = [
     "urgent and alarming", "calm and reassuring", "exciting and energetic", "trustworthy and professional",
     "warm and friendly", "bold and confident", "subtle and sophisticated", "raw and authentic",
@@ -85,9 +104,10 @@ NICHE_VISUAL_GUIDANCE: Dict[str, Dict[str, Any]] = {
         "color_preference": "trust",
     },
     "glp1": {
-        "subjects": ["confident person smiling", "active lifestyle scenes", "healthy meal preparation", "doctor consultation"],
+        "subjects": ["confident person smiling (age 30-50)", "active lifestyle scenes with adults", "healthy meal preparation", "doctor consultation", "person in their 30s-40s looking confident"],
         "props": ["fitness equipment", "healthy food", "comfortable clothing"],
-        "avoid": ["before/after weight comparisons", "measuring tapes", "scales prominently", "needle close-ups"],
+        "avoid": ["before/after weight comparisons", "measuring tapes", "scales prominently", "needle close-ups", "elderly people over 65", "senior citizens", "very old looking people", "gray-haired elderly groups"],
+        "age_guidance": "Show people aged 30-50 primarily. Avoid defaulting to elderly/senior citizens. Target audience is middle-aged adults, not seniors.",
         "color_preference": "health",
     },
 }
@@ -124,3 +144,18 @@ def get_random_visual_elements() -> Dict[str, Any]:
         "composition": get_random_composition(),
         "mood": get_random_mood(),
     }
+
+def get_random_visual_layout() -> Dict[str, Any]:
+    """Get a random visual layout/format."""
+    return random.choice(VISUAL_LAYOUTS)
+
+def get_visual_layout_by_key(key: str) -> Optional[Dict[str, Any]]:
+    """Get a specific visual layout by key."""
+    for layout in VISUAL_LAYOUTS:
+        if layout["key"] == key:
+            return layout
+    return None
+
+def get_all_visual_layouts() -> List[Dict[str, Any]]:
+    """Get all visual layouts."""
+    return VISUAL_LAYOUTS.copy()

frontend/app/gallery/[id]/page.tsx

@@ -10,10 +10,11 @@ import { getAd, deleteAd, listAds } from "@/lib/api/endpoints";
 import { formatDate, formatNiche, getImageUrl, getImageUrlFallback } from "@/lib/utils/formatters";
 import { downloadImage, copyToClipboard, exportAsJSON } from "@/lib/utils/export";
 import { toast } from "react-hot-toast";
-import { ArrowLeft, ArrowRight, Download, Copy, Trash2, FileJson, Wand2, History, RotateCcw, ChevronDown, ChevronUp, Edit3 } from "lucide-react";
-import type { AdCreativeDB, ImageCorrectResponse } from "@/types/api";
+import { ArrowLeft, ArrowRight, Download, Copy, Trash2, FileJson, Wand2, History, RotateCcw, ChevronDown, ChevronUp, Edit3, RefreshCw } from "lucide-react";
+import type { AdCreativeDB, ImageCorrectResponse, ImageRegenerateResponse } from "@/types/api";
 import { CorrectionModal } from "@/components/generation/CorrectionModal";
 import { EditCopyModal } from "@/components/generation/EditCopyModal";
+import { RegenerationModal } from "@/components/generation/RegenerationModal";
 
 export default function AdDetailPage() {
   const params = useParams();
@@ -27,6 +28,7 @@ export default function AdDetailPage() {
   const [allAds, setAllAds] = useState<AdCreativeDB[]>([]);
   const [currentIndex, setCurrentIndex] = useState<number>(-1);
   const [showCorrectionModal, setShowCorrectionModal] = useState(false);
+  const [showRegenerationModal, setShowRegenerationModal] = useState(false);
   const [showingOriginal, setShowingOriginal] = useState(false);
   const [isBodyStoryExpanded, setIsBodyStoryExpanded] = useState(false);
   const [editModal, setEditModal] = useState<{
@@ -267,6 +269,19 @@ export default function AdDetailPage() {
           )}
 
           <div className="flex items-center gap-1">
+            <div className="relative group">
+              <Button
+                variant="ghost"
+                size="sm"
+                onClick={() => setShowRegenerationModal(true)}
+                className="text-purple-600 hover:bg-purple-50"
+              >
+                <RefreshCw className="h-4 w-4" />
+              </Button>
+              <span className="absolute -bottom-8 left-1/2 -translate-x-1/2 px-2 py-1 bg-gray-800 text-white text-xs rounded opacity-0 group-hover:opacity-100 transition-opacity whitespace-nowrap pointer-events-none">
+                Regenerate Image
+              </span>
+            </div>
             <div className="relative group">
               <Button
                 variant="ghost"
@@ -635,6 +650,26 @@ export default function AdDetailPage() {
         }}
       />
 
+      {/* Regeneration Modal */}
+      <RegenerationModal
+        isOpen={showRegenerationModal}
+        onClose={() => setShowRegenerationModal(false)}
+        adId={adId}
+        ad={ad}
+        onSuccess={async (result: ImageRegenerateResponse) => {
+          // Reload the ad to get updated image and metadata
+          if (result.status === "success") {
+            toast.success("Image regenerated successfully!");
+            // Wait a moment for database to update, then reload
+            setTimeout(async () => {
+              await loadAd(); // Reload to get updated ad with new image and metadata
+              loadAllAds(); // Reload gallery list
+              setShowingOriginal(false); // Reset to show current image
+            }, 500);
+          }
+        }}
+      />
+
       {/* Edit Copy Modal */}
       {editModal && ad && (
         <EditCopyModal

frontend/components/generation/RegenerationModal.tsx

@@ -0,0 +1,364 @@
+"use client";
+
+import React, { useState, useEffect } from "react";
+import { X, RefreshCw, CheckCircle2, AlertCircle, Loader2, Sparkles, ChevronDown } from "lucide-react";
+import { regenerateImage, getImageModels } from "@/lib/api/endpoints";
+import type { ImageRegenerateResponse, AdCreativeDB, ImageModel } from "@/types/api";
+import { ProgressBar } from "@/components/ui/ProgressBar";
+import { Button } from "@/components/ui/Button";
+import { Card, CardContent } from "@/components/ui/Card";
+
+interface RegenerationModalProps {
+  isOpen: boolean;
+  onClose: () => void;
+  adId: string;
+  ad?: AdCreativeDB | null;
+  onSuccess?: (result: ImageRegenerateResponse) => void;
+}
+
+type RegenerationStep = "idle" | "input" | "regenerating" | "complete" | "error";
+
+export const RegenerationModal: React.FC<RegenerationModalProps> = ({
+  isOpen,
+  onClose,
+  adId,
+  ad,
+  onSuccess,
+}) => {
+  const [step, setStep] = useState<RegenerationStep>("idle");
+  const [progress, setProgress] = useState(0);
+  const [result, setResult] = useState<ImageRegenerateResponse | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [selectedModel, setSelectedModel] = useState<string | null>(null);
+  const [models, setModels] = useState<ImageModel[]>([]);
+  const [defaultModel, setDefaultModel] = useState<string>("");
+  const [loadingModels, setLoadingModels] = useState(false);
+
+  useEffect(() => {
+    if (isOpen) {
+      setStep("input");
+      setProgress(0);
+      setResult(null);
+      setError(null);
+      // Load available models
+      loadModels();
+    } else {
+      // Reset state when modal closes
+      setStep("idle");
+      setProgress(0);
+      setResult(null);
+      setError(null);
+      setSelectedModel(null);
+    }
+  }, [isOpen]);
+
+  const loadModels = async () => {
+    setLoadingModels(true);
+    try {
+      const response = await getImageModels();
+      setModels(response.models);
+      setDefaultModel(response.default);
+      // Set initial selection to current ad's model or default
+      setSelectedModel(ad?.image_model || response.default);
+    } catch (err: any) {
+      console.error("Failed to load models:", err);
+      // Use fallback models if API fails
+      setModels([
+        { key: "nano-banana", id: "google/nano-banana", uses_dimensions: false },
+        { key: "nano-banana-pro", id: "google/nano-banana-pro", uses_dimensions: false },
+        { key: "z-image-turbo", id: "prunaai/z-image-turbo", uses_dimensions: true },
+        { key: "imagen-4-ultra", id: "google/imagen-4-ultra", uses_dimensions: false },
+        { key: "recraft-v3", id: "recraft-ai/recraft-v3", uses_dimensions: false },
+        { key: "ideogram-v3", id: "ideogram-ai/ideogram-v3-quality", uses_dimensions: false },
+        { key: "photon", id: "luma/photon", uses_dimensions: false },
+        { key: "seedream-3", id: "bytedance/seedream-3", uses_dimensions: false },
+      ]);
+      setDefaultModel("nano-banana");
+      setSelectedModel(ad?.image_model || "nano-banana");
+    } finally {
+      setLoadingModels(false);
+    }
+  };
+
+  const handleRegenerate = async () => {
+    setStep("regenerating");
+    setProgress(0);
+    setError(null);
+    setResult(null);
+
+    try {
+      // Simulate progress updates
+      const progressInterval = setInterval(() => {
+        setProgress((prev) => {
+          if (prev < 90) {
+            return prev + 3;
+          }
+          return prev;
+        });
+      }, 400);
+
+      // Actually perform the regeneration
+      const response = await regenerateImage({ 
+        image_id: adId,
+        image_model: selectedModel,
+      });
+
+      clearInterval(progressInterval);
+      setProgress(100);
+
+      if (response.status === "success") {
+        setStep("complete");
+        setResult(response);
+      } else {
+        setStep("error");
+        setError(response.error || "Regeneration failed");
+      }
+    } catch (err: any) {
+      setStep("error");
+      setError(err.response?.data?.detail || err.message || "Failed to regenerate image");
+      setProgress(0);
+    }
+  };
+
+  const getStepLabel = () => {
+    switch (step) {
+      case "input":
+        return "Select Model";
+      case "regenerating":
+        return "Regenerating image...";
+      case "complete":
+        return "Regeneration complete!";
+      case "error":
+        return "Error occurred";
+      default:
+        return "Starting regeneration...";
+    }
+  };
+
+  const getStepIcon = () => {
+    switch (step) {
+      case "complete":
+        return <CheckCircle2 className="h-6 w-6 text-green-500" />;
+      case "error":
+        return <AlertCircle className="h-6 w-6 text-red-500" />;
+      default:
+        return <Loader2 className="h-6 w-6 text-blue-500 animate-spin" />;
+    }
+  };
+
+  const getModelDisplayName = (key: string) => {
+    const displayNames: Record<string, string> = {
+      "z-image-turbo": "Z-Image Turbo",
+      "nano-banana": "Nano Banana",
+      "nano-banana-pro": "Nano Banana Pro",
+      "imagen-4": "Imagen 4",
+      "imagen-4-ultra": "Imagen 4 Ultra",
+      "recraft-v3": "Recraft V3",
+      "ideogram-v3": "Ideogram V3 Quality",
+      "photon": "Luma Photon",
+      "seedream-3": "SeedReam 3",
+      "gpt-image-1.5": "GPT Image 1.5 (OpenAI)",
+    };
+    return displayNames[key] || key;
+  };
+
+  if (!isOpen) return null;
+
+  return (
+    <div className="fixed inset-0 z-50 flex items-center justify-center p-4 bg-black/60 backdrop-blur-sm">
+      <div className="bg-white rounded-2xl shadow-2xl max-w-2xl w-full max-h-[90vh] overflow-y-auto">
+        {/* Header */}
+        <div className="sticky top-0 bg-white border-b border-gray-200 px-6 py-4 rounded-t-2xl z-10">
+          <div className="flex items-center justify-between">
+            <div className="flex items-center gap-3">
+              <div className="p-2 bg-gradient-to-r from-purple-500 to-pink-500 rounded-lg">
+                <RefreshCw className="h-5 w-5 text-white" />
+              </div>
+              <div>
+                <h2 className="text-xl font-bold text-gray-900">Regenerate Image</h2>
+                <p className="text-sm text-gray-500">
+                  {step === "input" 
+                    ? "Generate a new version of your image" 
+                    : "Creating a new image with the same prompt"}
+                </p>
+              </div>
+            </div>
+            <button
+              onClick={onClose}
+              className="p-2 hover:bg-gray-100 rounded-lg transition-colors"
+            >
+              <X className="h-5 w-5 text-gray-500" />
+            </button>
+          </div>
+        </div>
+
+        {/* Content */}
+        <div className="p-6 space-y-6">
+          {/* Input Step */}
+          {step === "input" && (
+            <div className="space-y-4">
+              <Card variant="glass">
+                <CardContent className="pt-6">
+                  <div className="space-y-4">
+                    {/* Current Model Info */}
+                    {ad?.image_model && (
+                      <div className="bg-gray-50 border border-gray-200 rounded-lg p-3">
+                        <p className="text-xs text-gray-500 mb-1">Current Model</p>
+                        <p className="font-medium text-gray-900">{getModelDisplayName(ad.image_model)}</p>
+                      </div>
+                    )}
+
+                    {/* Model Selection */}
+                    <div>
+                      <label className="block text-sm font-semibold text-gray-700 mb-2">
+                        Select Image Model
+                      </label>
+                      {loadingModels ? (
+                        <div className="flex items-center justify-center py-4">
+                          <Loader2 className="h-5 w-5 text-blue-500 animate-spin" />
+                          <span className="ml-2 text-sm text-gray-500">Loading models...</span>
+                        </div>
+                      ) : (
+                        <div className="relative">
+                          <select
+                            value={selectedModel || ""}
+                            onChange={(e) => setSelectedModel(e.target.value)}
+                            className="w-full px-4 py-3 bg-white border border-gray-300 rounded-lg appearance-none focus:outline-none focus:ring-2 focus:ring-purple-500 focus:border-transparent text-gray-900 font-medium"
+                          >
+                            {models.map((model) => (
+                              <option key={model.key} value={model.key}>
+                                {getModelDisplayName(model.key)}
+                                {model.key === defaultModel ? " (Default)" : ""}
+                                {model.key === ad?.image_model ? " (Current)" : ""}
+                              </option>
+                            ))}
+                          </select>
+                          <ChevronDown className="absolute right-3 top-1/2 -translate-y-1/2 h-5 w-5 text-gray-400 pointer-events-none" />
+                        </div>
+                      )}
+                      <p className="text-xs text-gray-500 mt-2">
+                        Different models produce different styles. Try a new model for variety!
+                      </p>
+                    </div>
+
+                    {/* Info about what will happen */}
+                    <div className="bg-purple-50 border border-purple-200 rounded-lg p-3 text-sm text-purple-800">
+                      <p className="font-semibold mb-1">How it works</p>
+                      <ul className="list-disc list-inside space-y-1 text-purple-700">
+                        <li>Uses the same prompt as the original image</li>
+                        <li>Generates a completely new image with a fresh seed</li>
+                        <li>Original image info is preserved in metadata</li>
+                      </ul>
+                    </div>
+                  </div>
+                </CardContent>
+              </Card>
+            </div>
+          )}
+
+          {/* Progress Section */}
+          {step === "regenerating" && (
+            <div className="space-y-4">
+              <div className="flex items-center gap-4">
+                {getStepIcon()}
+                <div className="flex-1">
+                  <p className="font-semibold text-gray-900">{getStepLabel()}</p>
+                  <p className="text-sm text-gray-500 mb-2">Using {getModelDisplayName(selectedModel || defaultModel)}</p>
+                  <ProgressBar progress={progress} showPercentage={true} className="mt-2" />
+                </div>
+              </div>
+            </div>
+          )}
+
+          {/* Error State */}
+          {step === "error" && (
+            <div className="bg-red-50 border border-red-200 rounded-xl p-4">
+              <div className="flex items-start gap-3">
+                <AlertCircle className="h-5 w-5 text-red-500 mt-0.5" />
+                <div className="flex-1">
+                  <h3 className="font-semibold text-red-900 mb-1">Regeneration Failed</h3>
+                  <p className="text-sm text-red-700">{error}</p>
+                </div>
+              </div>
+            </div>
+          )}
+
+          {/* Success State */}
+          {step === "complete" && result && (
+            <div className="space-y-4">
+              <div className="bg-green-50 border border-green-200 rounded-xl p-4">
+                <div className="flex items-center gap-3">
+                  <CheckCircle2 className="h-5 w-5 text-green-500" />
+                  <div>
+                    <h3 className="font-semibold text-green-900">Regeneration Complete!</h3>
+                    <p className="text-sm text-green-700">Your image has been regenerated successfully</p>
+                  </div>
+                </div>
+              </div>
+
+              {result.regenerated_image?.image_url && (
+                <div className="space-y-3">
+                  <h3 className="font-semibold text-gray-900">New Image</h3>
+                  <img
+                    src={result.regenerated_image.image_url}
+                    alt="Regenerated"
+                    className="w-full rounded-lg border border-gray-200"
+                  />
+                </div>
+              )}
+
+              {/* Show model used */}
+              {result.regenerated_image?.model_used && (
+                <div className="bg-gray-50 border border-gray-200 rounded-lg p-3">
+                  <p className="text-xs text-gray-500 mb-1">Model Used</p>
+                  <p className="font-medium text-gray-900">
+                    {getModelDisplayName(result.regenerated_image.model_used)}
+                  </p>
+                </div>
+              )}
+
+              {result.original_preserved && (
+                <div className="bg-blue-50 border border-blue-200 rounded-lg p-3 text-sm text-blue-800">
+                  <p>The original image info has been preserved in the ad metadata. You can view it from the ad detail page.</p>
+                </div>
+              )}
+            </div>
+          )}
+        </div>
+
+        {/* Footer */}
+        <div className="sticky bottom-0 bg-gray-50 border-t border-gray-200 px-6 py-4 rounded-b-2xl">
+          <div className="flex justify-end gap-3">
+            {step === "input" && (
+              <Button 
+                onClick={handleRegenerate} 
+                variant="primary"
+                disabled={!selectedModel || loadingModels}
+              >
+                <Sparkles className="h-4 w-4 mr-2" />
+                Regenerate Image
+              </Button>
+            )}
+            {step === "error" && (
+              <Button onClick={() => setStep("input")} variant="primary">
+                Try Again
+              </Button>
+            )}
+            <Button
+              onClick={() => {
+                if (step === "complete" && result) {
+                  // Call onSuccess when user clicks "Done" to reload the ad
+                  onSuccess?.(result);
+                }
+                onClose();
+              }}
+              variant={step === "complete" ? "primary" : "secondary"}
+            >
+              {step === "complete" ? "Done" : "Close"}
+            </Button>
+          </div>
+        </div>
+      </div>
+    </div>
+  );
+};

frontend/lib/api/endpoints.ts

@@ -15,6 +15,8 @@ import type {
   HealthResponse,
   ApiRootResponse,
   ImageCorrectResponse,
+  ImageRegenerateResponse,
+  ModelsListResponse,
   LoginResponse,
   Niche,
   CreativeAnalysisResponse,
@@ -175,6 +177,21 @@ export const correctImage = async (params: {
   return response.data;
 };
 
+// Image Regeneration Endpoints
+export const regenerateImage = async (params: {
+  image_id: string;
+  image_model?: string | null;
+}): Promise<ImageRegenerateResponse> => {
+  const response = await apiClient.post<ImageRegenerateResponse>("/api/regenerate", params);
+  return response.data;
+};
+
+// Get Available Image Models
+export const getImageModels = async (): Promise<ModelsListResponse> => {
+  const response = await apiClient.get<ModelsListResponse>("/api/models");
+  return response.data;
+};
+
 // Auth Endpoints
 export const login = async (username: string, password: string): Promise<LoginResponse> => {
   const response = await apiClient.post<LoginResponse>("/auth/login", {

frontend/types/api.ts

@@ -189,9 +189,13 @@ export interface AdCreativeDB {
     original_image_filename?: string | null;
     original_image_model?: string | null;
     original_image_prompt?: string | null;
+    original_seed?: number | null;
     is_corrected?: boolean;
     correction_date?: string | null;
     corrections?: CorrectionData | null;
+    is_regenerated?: boolean;
+    regeneration_date?: string | null;
+    regeneration_seed?: number | null;
     visual_style?: string | null;
     [key: string]: any;
   } | null;
@@ -321,3 +325,31 @@ export interface FileUploadResponse {
 }
 
 export type ModificationMode = "modify" | "inspired";
+
+// Image Regeneration Types
+export interface RegeneratedImageResult {
+  filename?: string | null;
+  filepath?: string | null;
+  image_url?: string | null;
+  r2_url?: string | null;
+  model_used?: string | null;
+  prompt_used?: string | null;
+}
+
+export interface ImageRegenerateResponse {
+  status: string;
+  regenerated_image?: RegeneratedImageResult | null;
+  original_preserved: boolean;
+  error?: string | null;
+}
+
+export interface ImageModel {
+  key: string;
+  id: string;
+  uses_dimensions: boolean;
+}
+
+export interface ModelsListResponse {
+  models: ImageModel[];
+  default: string;
+}

main.py

@@ -15,6 +15,8 @@ from datetime import datetime
 import os
 import logging
 import time
+import random
+import uuid
 from starlette.middleware.gzip import GZipMiddleware
 import httpx
 from starlette.requests import Request as StarletteRequest
@@ -359,6 +361,8 @@ async def api_info():
             "GET /matrix/compatible/{angle_key}": "Get compatible concepts for angle",
             "POST /extensive/generate": "Generate ad using extensive (researcher → creative director → designer → copywriter)",
             "POST /api/correct": "Correct image for spelling mistakes and visual issues (requires image_id)",
+            "POST /api/regenerate": "Regenerate image with optional model selection (requires image_id)",
+            "GET /api/models": "List all available image generation models",
             "POST /api/creative/upload": "Upload a creative image for analysis",
             "POST /api/creative/analyze": "Analyze a creative image with AI vision (via URL)",
             "POST /api/creative/analyze/upload": "Analyze a creative image with AI vision (via file upload)",
@@ -881,6 +885,266 @@ async def correct_image(
 
 
 
+# =============================================================================
+# IMAGE REGENERATION ENDPOINTS
+# =============================================================================
+
+class ImageRegenerateRequest(BaseModel):
+    """Request schema for image regeneration."""
+    image_id: str = Field(
+        description="ID of existing ad creative in database"
+    )
+    image_model: Optional[str] = Field(
+        default=None,
+        description="Image generation model to use (e.g., 'z-image-turbo', 'nano-banana', 'nano-banana-pro', 'imagen-4-ultra', 'recraft-v3', 'ideogram-v3', 'photon', 'seedream-3'). If not provided, uses the original model."
+    )
+
+
+class RegeneratedImageResult(BaseModel):
+    """Regenerated image result."""
+    filename: Optional[str] = None
+    filepath: Optional[str] = None
+    image_url: Optional[str] = None
+    r2_url: Optional[str] = None
+    model_used: Optional[str] = None
+    prompt_used: Optional[str] = None
+
+
+class ImageRegenerateResponse(BaseModel):
+    """Response schema for image regeneration."""
+    status: str
+    regenerated_image: Optional[RegeneratedImageResult] = None
+    original_preserved: bool = Field(default=True, description="Whether original image info was preserved in metadata")
+    error: Optional[str] = None
+
+
+@app.post("/api/regenerate", response_model=ImageRegenerateResponse)
+async def regenerate_image(
+    request: ImageRegenerateRequest,
+    username: str = Depends(get_current_user)
+):
+    """
+    Regenerate an image for an existing ad creative with an optional new model.
+    
+    Requires authentication. Users can only regenerate their own ads.
+    
+    The service will:
+    1. Fetch the original ad and its image prompt from the database
+    2. Regenerate the image using the specified model (or original model if not provided)
+    3. Upload to R2 storage
+    4. Update the ad with the new image, preserving original image info in metadata
+    5. Return the regenerated image
+    """
+    api_start_time = time.time()
+    api_logger.info("=" * 80)
+    api_logger.info(f"API: Regeneration request received")
+    api_logger.info(f"User: {username}")
+    api_logger.info(f"Image ID: {request.image_id}")
+    api_logger.info(f"Requested model: {request.image_model or 'Use original'}")
+    
+    try:
+        # Fetch ad from database (only if it belongs to current user)
+        api_logger.info(f"Fetching ad creative from database...")
+        ad = await db_service.get_ad_creative(request.image_id, username=username)
+        if not ad:
+            api_logger.error(f"Ad creative {request.image_id} not found or access denied for user {username}")
+            raise HTTPException(status_code=404, detail=f"Ad creative with ID {request.image_id} not found or access denied")
+        
+        api_logger.info(f"Ad creative found: {ad.get('title', 'N/A')} (niche: {ad.get('niche', 'N/A')})")
+        
+        # Get the image prompt
+        image_prompt = ad.get("image_prompt")
+        if not image_prompt:
+            api_logger.error(f"No image prompt found for ad {request.image_id}")
+            raise HTTPException(
+                status_code=400,
+                detail="No image prompt found for this ad creative. Cannot regenerate without a prompt."
+            )
+        
+        api_logger.info(f"Image prompt found: {len(image_prompt)} characters")
+        
+        # Determine which model to use
+        model_to_use = request.image_model or ad.get("image_model") or settings.image_model
+        api_logger.info(f"Using model: {model_to_use}")
+        
+        # Generate a new random seed for variety
+        seed = random.randint(1, 2147483647)
+        api_logger.info(f"Using seed: {seed}")
+        
+        # Generate the new image
+        api_logger.info("Generating new image...")
+        try:
+            image_bytes, model_used, generated_url = await image_service.generate(
+                prompt=image_prompt,
+                width=1024,
+                height=1024,
+                seed=seed,
+                model_key=model_to_use,
+            )
+        except Exception as e:
+            api_logger.error(f"Image generation failed: {e}")
+            raise HTTPException(status_code=500, detail=f"Image generation failed: {str(e)}")
+        
+        api_logger.info(f"Image generated successfully with model: {model_used}")
+        
+        # Generate filename for the new image
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        unique_id = uuid.uuid4().hex[:8]
+        niche = ad.get("niche", "unknown").replace(" ", "_")
+        filename = f"regen_{niche}_{timestamp}_{unique_id}.png"
+        
+        # Try to upload to R2
+        r2_url = None
+        try:
+            from services.r2_storage import get_r2_storage
+            r2_storage = get_r2_storage()
+            if r2_storage and image_bytes:
+                r2_url = r2_storage.upload_image(
+                    image_bytes=image_bytes,
+                    filename=filename,
+                    niche=niche,
+                )
+                api_logger.info(f"Uploaded to R2: {r2_url}")
+        except Exception as e:
+            api_logger.warning(f"R2 upload failed: {e}")
+        
+        # Save locally as fallback
+        local_path = None
+        if not r2_url and image_bytes:
+            local_path = os.path.join(settings.output_dir, filename)
+            os.makedirs(os.path.dirname(local_path), exist_ok=True)
+            with open(local_path, "wb") as f:
+                f.write(image_bytes)
+            api_logger.info(f"Saved locally: {local_path}")
+        
+        # Prepare to update the ad
+        # Store old image data in metadata before updating
+        old_image_url = ad.get("r2_url") or ad.get("image_url")
+        old_r2_url = ad.get("r2_url")
+        old_image_filename = ad.get("image_filename")
+        old_image_model = ad.get("image_model")
+        old_seed = ad.get("image_seed")
+        
+        # Build metadata with original image info
+        regeneration_metadata = {
+            "is_regenerated": True,
+            "regeneration_date": datetime.utcnow().isoformat() + "Z",
+            "regeneration_seed": seed,
+        }
+        
+        if old_image_url:
+            regeneration_metadata["original_image_url"] = old_image_url
+        if old_r2_url:
+            regeneration_metadata["original_r2_url"] = old_r2_url
+        if old_image_filename:
+            regeneration_metadata["original_image_filename"] = old_image_filename
+        if old_image_model:
+            regeneration_metadata["original_image_model"] = old_image_model
+        if old_seed:
+            regeneration_metadata["original_seed"] = old_seed
+        
+        # Update the ad with new image
+        update_kwargs = {
+            "image_filename": filename,
+            "image_model": model_used,
+            "image_seed": seed,
+        }
+        if r2_url:
+            update_kwargs["image_url"] = r2_url
+            update_kwargs["r2_url"] = r2_url
+        elif generated_url:
+            update_kwargs["image_url"] = generated_url
+        elif local_path:
+            update_kwargs["image_url"] = f"/images/{filename}"
+        
+        api_logger.info(f"Updating ad {request.image_id} with new image...")
+        update_success = await db_service.update_ad_creative(
+            ad_id=request.image_id,
+            username=username,
+            metadata=regeneration_metadata,
+            **update_kwargs
+        )
+        
+        if update_success:
+            api_logger.info(f"✓ Ad updated with regenerated image (ID: {request.image_id})")
+        else:
+            api_logger.warning("Failed to update ad with regenerated image")
+        
+        total_api_time = time.time() - api_start_time
+        api_logger.info("=" * 80)
+        api_logger.info(f"✓ API: Regeneration completed successfully in {total_api_time:.2f}s")
+        api_logger.info("=" * 80)
+        
+        return {
+            "status": "success",
+            "regenerated_image": {
+                "filename": filename,
+                "filepath": local_path,
+                "image_url": r2_url or generated_url or f"/images/{filename}",
+                "r2_url": r2_url,
+                "model_used": model_used,
+                "prompt_used": image_prompt,
+            },
+            "original_preserved": True,
+        }
+        
+    except HTTPException:
+        total_api_time = time.time() - api_start_time
+        api_logger.error(f"✗ API: Regeneration request failed with HTTPException after {total_api_time:.2f}s")
+        raise
+    except Exception as e:
+        total_api_time = time.time() - api_start_time
+        api_logger.error(f"✗ API: Regeneration request failed with exception after {total_api_time:.2f}s: {str(e)}")
+        api_logger.exception("Full exception traceback:")
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+@app.get("/api/models")
+async def list_image_models():
+    """
+    List all available image generation models.
+    
+    Returns model keys and their descriptions for use in image generation/regeneration.
+    Default for regeneration is nano-banana (best quality for affiliate marketing).
+    """
+    from services.image import MODEL_REGISTRY
+    
+    # Order models with nano-banana first (recommended for regeneration)
+    preferred_order = ["nano-banana", "nano-banana-pro", "z-image-turbo", "imagen-4-ultra", "recraft-v3", "ideogram-v3", "photon", "seedream-3"]
+    
+    models = []
+    # Add models in preferred order first
+    for key in preferred_order:
+        if key in MODEL_REGISTRY:
+            config = MODEL_REGISTRY[key]
+            models.append({
+                "key": key,
+                "id": config["id"],
+                "uses_dimensions": config.get("uses_dimensions", False),
+            })
+    
+    # Add any remaining models not in preferred order
+    for key, config in MODEL_REGISTRY.items():
+        if key not in preferred_order:
+            models.append({
+                "key": key,
+                "id": config["id"],
+                "uses_dimensions": config.get("uses_dimensions", False),
+            })
+    
+    # Add OpenAI model at the end
+    models.append({
+        "key": "gpt-image-1.5",
+        "id": "openai/gpt-image-1.5",
+        "uses_dimensions": True,
+    })
+    
+    return {
+        "models": models,
+        "default": "nano-banana",  # Best for affiliate marketing regeneration
+    }
+
+
 @app.get("/strategies/{niche}")
 async def get_strategies(niche: Literal["home_insurance", "glp1"]):
     """

services/generator.py

@@ -962,7 +962,9 @@ NICHE REQUIREMENTS (GLP-1):
 - Confidence/transformation moments should feel genuine
 - AVOID: defaulting to before/after for every image - prioritize visual variety
 - AVOID: extreme body manipulation, unrealistic transformations, shame-inducing imagery
+- AVOID: elderly people over 65, senior citizens, very old looking people, gray-haired elderly groups
 - ENCOURAGE: diverse visual concepts that match the strategy (quiz for quiz strategy, medical for authority strategy, lifestyle for aspiration, etc.)
+- AGE GUIDANCE: Show people aged 30-50 primarily. DO NOT default to elderly/senior citizens. Target audience is middle-aged adults (30s-40s), NOT seniors.
 """
         else:
             niche_image_guidance = ""
@@ -1192,147 +1194,210 @@ CRITICAL REQUIREMENTS:
 - Focus on the natural, authentic scene only
 - If text is included, show it in ONE location only, not multiple places"""
 
-        # Refine and clean the prompt before sending
-        refined_prompt = self._refine_image_prompt(prompt)
+        # Refine and clean the prompt before sending (pass niche for demographic fixes)
+        refined_prompt = self._refine_image_prompt(prompt, niche=niche)
         return refined_prompt
     
-    def _refine_image_prompt(self, prompt: str) -> str:
+    def _refine_image_prompt(self, prompt: str, niche: str = None) -> str:
         """
-        Refine and clean the image prompt to ensure logical, coherent image generation.
-        Removes contradictions, confusing instructions, and ensures the prompt makes sense.
+        Refine and clean the image prompt for affiliate marketing creatives.
+        
+        Fixes illogical elements:
+        - Contradictory instructions
+        - Wrong demographics for niche
+        - Unrealistic visual combinations
+        - Corporate/stock photo aesthetics (bad for affiliate marketing)
+        - Meta-instructions that confuse image models
+        
+        Affiliate marketing principle: Low-production, authentic images outperform polished studio shots.
         """
         import re
         
-        # Remove meta-instructions that confuse the model
-        prompt = re.sub(r'\(for model, not to display\)', '', prompt, flags=re.IGNORECASE)
-        prompt = re.sub(r'\(apply these, don\'t display\)', '', prompt, flags=re.IGNORECASE)
-        prompt = re.sub(r'IMPORTANT: Display ONLY', 'Display', prompt, flags=re.IGNORECASE)
-        prompt = re.sub(r'IMPORTANT: If including', 'If including', prompt, flags=re.IGNORECASE)
-        prompt = re.sub(r'IMPORTANT: Use this', 'Use this', prompt, flags=re.IGNORECASE)
-        prompt = re.sub(r'IMPORTANT: Follow this', 'Follow this', prompt, flags=re.IGNORECASE)
+        # =====================================================================
+        # 1. REMOVE META-INSTRUCTIONS (confuse image models)
+        # =====================================================================
+        meta_patterns = [
+            r'\(for model, not to display\)',
+            r'\(apply these, don\'t display\)',
+            r'\(for reference only\)',
+            r'\(internal use\)',
+            r'IMPORTANT: Display ONLY',
+            r'IMPORTANT: If including',
+            r'IMPORTANT: Use this',
+            r'IMPORTANT: Follow this',
+            r'CRITICAL: Do not',
+            r'NOTE: This is for',
+        ]
+        for pattern in meta_patterns:
+            prompt = re.sub(pattern, '', prompt, flags=re.IGNORECASE)
+        
+        # =====================================================================
+        # 2. FIX DEMOGRAPHIC ISSUES (niche-specific)
+        # =====================================================================
+        prompt_lower = prompt.lower()
         
-        # Remove lines that are clearly instructions for developers, not the model
+        # GLP-1: Fix elderly/senior defaults - target is 30-50 adults
+        if niche and niche.lower() == 'glp1':
+            # Replace elderly references with middle-aged
+            elderly_replacements = [
+                (r'\b(elderly|senior|seniors|old people|old person)\b', 'middle-aged adult'),
+                (r'\b(grandparent|grandfather|grandmother|grandma|grandpa)\b', 'parent'),
+                (r'\b(70[\s-]?year[\s-]?old|80[\s-]?year[\s-]?old|65[\s-]?year[\s-]?old)\b', '40-year-old'),
+                (r'\b(in their 60s|in their 70s|in their 80s)\b', 'in their 40s'),
+                (r'\b(retirement age|retired person|retiree)\b', 'working professional'),
+                (r'\bgray[\s-]?haired elderly\b', 'confident adult'),
+                (r'\bsenior citizen\b', 'adult'),
+            ]
+            for pattern, replacement in elderly_replacements:
+                prompt = re.sub(pattern, replacement, prompt, flags=re.IGNORECASE)
+        
+        # Home Insurance: Ensure American suburban context
+        if niche and niche.lower() == 'home_insurance':
+            # Fix non-American home references
+            home_replacements = [
+                (r'\b(flat|apartment|condo)\b(?! insurance)', 'house'),
+                (r'\b(mansion|castle|estate)\b', 'suburban home'),
+                (r'\b(european|british|uk) style home\b', 'American suburban home'),
+            ]
+            for pattern, replacement in home_replacements:
+                prompt = re.sub(pattern, replacement, prompt, flags=re.IGNORECASE)
+        
+        # =====================================================================
+        # 3. FIX ILLOGICAL VISUAL COMBINATIONS
+        # =====================================================================
+        
+        # Can't have both "no text" and "headline text"
+        if 'no text' in prompt_lower and ('headline' in prompt_lower or 'text overlay' in prompt_lower):
+            # Keep "no text" instruction, remove headline sections
+            prompt = re.sub(
+                r'===.*HEADLINE.*===[\s\S]*?(?====|$)',
+                '',
+                prompt,
+                flags=re.IGNORECASE | re.MULTILINE
+            )
+            prompt = re.sub(r'headline[:\s]+["\']?[^"\']+["\']?', '', prompt, flags=re.IGNORECASE)
+        
+        # Can't have both "minimalist" and "cluttered/busy"
+        if 'minimalist' in prompt_lower and any(word in prompt_lower for word in ['cluttered', 'busy', 'crowded', 'chaotic']):
+            prompt = re.sub(r'\b(cluttered|busy|crowded|chaotic)\b', 'clean', prompt, flags=re.IGNORECASE)
+        
+        # Can't have both "dark/moody" and "bright/cheerful"
+        if 'dark' in prompt_lower and 'moody' in prompt_lower:
+            prompt = re.sub(r'\b(bright|cheerful|sunny|vibrant)\b', 'subtle', prompt, flags=re.IGNORECASE)
+        elif 'bright' in prompt_lower and 'cheerful' in prompt_lower:
+            prompt = re.sub(r'\b(dark|moody|dramatic|gloomy)\b', 'soft', prompt, flags=re.IGNORECASE)
+        
+        # Can't have "indoor" scene with "outdoor" elements
+        if 'indoor' in prompt_lower or 'inside' in prompt_lower:
+            if 'sunlight streaming' not in prompt_lower:  # Window light is okay
+                prompt = re.sub(r'\b(outdoor|outside|garden|yard|street)\b(?! view)', 'indoor', prompt, flags=re.IGNORECASE)
+        
+        # =====================================================================
+        # 4. FIX AFFILIATE MARKETING ANTI-PATTERNS
+        # =====================================================================
+        
+        # Remove corporate/stock photo aesthetics (bad for affiliate marketing)
+        stock_photo_terms = [
+            (r'\bstock photo\b', 'authentic photo'),
+            (r'\bprofessional studio\b', 'natural setting'),
+            (r'\bperfect lighting\b', 'natural lighting'),
+            (r'\bcorporate headshot\b', 'candid portrait'),
+            (r'\bpolished commercial\b', 'authentic UGC-style'),
+            (r'\bgeneric model\b', 'real person'),
+            (r'\bshutterstock style\b', 'authentic casual'),
+            (r'\bistock style\b', 'documentary style'),
+        ]
+        for pattern, replacement in stock_photo_terms:
+            prompt = re.sub(pattern, replacement, prompt, flags=re.IGNORECASE)
+        
+        # Ensure authenticity markers for affiliate marketing
+        if 'ugc' in prompt_lower or 'authentic' in prompt_lower:
+            # Remove conflicting professional markers
+            prompt = re.sub(r'\b(studio backdrop|professional lighting setup|commercial shoot)\b', 
+                          'natural environment', prompt, flags=re.IGNORECASE)
+        
+        # =====================================================================
+        # 5. FIX UNREALISTIC BODY/TRANSFORMATION CLAIMS
+        # =====================================================================
+        
+        # Remove extreme/unrealistic transformation language
+        unrealistic_patterns = [
+            (r'\b(extreme weight loss|dramatic transformation overnight)\b', 'healthy transformation'),
+            (r'\b(impossibly thin|skeletal|anorexic)\b', 'healthy fit'),
+            (r'\b(perfect body|flawless figure)\b', 'confident healthy body'),
+            (r'\b(six pack abs|bodybuilder physique)\b', 'healthy toned body'),
+        ]
+        for pattern, replacement in unrealistic_patterns:
+            prompt = re.sub(pattern, replacement, prompt, flags=re.IGNORECASE)
+        
+        # =====================================================================
+        # 6. CLEAN UP FORMATTING AND STRUCTURE
+        # =====================================================================
+        
+        # Remove developer instructions
         lines = prompt.split('\n')
         cleaned_lines = []
-        skip_until_next_section = False
-        
         for line in lines:
             line_lower = line.lower()
-            
-            # Skip developer instructions
+            # Skip developer-only lines
             if any(phrase in line_lower for phrase in [
-                'do not display these instructions',
-                'not to be displayed',
-                'for debugging',
-                'metadata',
+                'do not display', 'not to be displayed', 'for debugging',
+                'metadata:', 'internal:', 'developer note'
             ]):
-                if not line.strip().startswith('==='):
-                    continue
-            
-            # Keep section headers
-            if line.strip().startswith('==='):
-                skip_until_next_section = False
-                cleaned_lines.append(line)
                 continue
-            
-            # Skip placeholder or empty content
-            if any(phrase in line_lower for phrase in ['n/a', 'not provided', 'see above', 'refer to']):
-                if not line.strip().startswith('-'):
-                    continue
-            
-            # Simplify overly emphatic instructions
-            if line.strip().startswith('CRITICAL:'):
-                line = line.replace('CRITICAL:', 'Note:')
-            elif line.strip().startswith('IMPORTANT:'):
-                line = line.replace('IMPORTANT:', 'Note:')
-            
-            # Remove redundant "NO" statements that are already covered
-            if line.strip().startswith('- NO') and 'decorative' in line_lower:
-                # Keep first occurrence, skip duplicates
-                if 'decorative' in '\n'.join(cleaned_lines).lower():
-                    # Check if we already have this prohibition
+            # Skip empty placeholder content
+            if any(phrase in line_lower for phrase in ['n/a', 'not provided', 'see above', 'tbd']):
+                if len(line.strip()) < 20:  # Short placeholder lines
                     continue
-            
             cleaned_lines.append(line)
-        
         prompt = '\n'.join(cleaned_lines)
         
+        # Simplify emphatic markers (image models don't need shouting)
+        prompt = re.sub(r'\bCRITICAL:\s*', '', prompt, flags=re.IGNORECASE)
+        prompt = re.sub(r'\bIMPORTANT:\s*', '', prompt, flags=re.IGNORECASE)
+        prompt = re.sub(r'\bNOTE:\s*', '', prompt, flags=re.IGNORECASE)
+        prompt = re.sub(r'\bMUST:\s*', '', prompt, flags=re.IGNORECASE)
+        
         # Remove excessive blank lines
         prompt = re.sub(r'\n{3,}', '\n\n', prompt)
         
-        # Ensure logical coherence - check for contradictions
-        prompt_lower = prompt.lower()
+        # Remove empty sections
+        prompt = re.sub(r'===\s*===', '', prompt)
+        prompt = re.sub(r'===\s*\n\s*===', '===', prompt)
+        
+        # =====================================================================
+        # 7. ENSURE LOGICAL COHERENCE
+        # =====================================================================
+        
+        # Remove duplicate prohibitions
+        seen_prohibitions = set()
+        final_lines = []
+        for line in prompt.split('\n'):
+            line_lower = line.lower().strip()
+            if line_lower.startswith('- no ') or line_lower.startswith('no '):
+                prohibition_key = re.sub(r'[^a-z\s]', '', line_lower)[:50]
+                if prohibition_key in seen_prohibitions:
+                    continue
+                seen_prohibitions.add(prohibition_key)
+            final_lines.append(line)
+        prompt = '\n'.join(final_lines)
         
-        # If we say "no text" but have headline section, clarify
-        if 'no text overlay' in prompt_lower or 'no text' in prompt_lower:
-            # Remove or clarify headline text section
-            sections = prompt.split('===')
-            filtered_sections = []
-            for section in sections:
-                section_lower = section.lower()
-                # Keep "no text" instructions
-                if 'no text' in section_lower and 'overlay' in section_lower:
-                    filtered_sections.append(section)
-                # Skip headline text section if we said no text
-                elif 'headline text' in section_lower and 'no text' in prompt_lower:
-                    # Replace with clarification
-                    filtered_sections.append('=== NO TEXT ===\nDo NOT include any text in this image.')
-                else:
-                    filtered_sections.append(section)
-            prompt = '==='.join(filtered_sections)
-        
-        # Ensure visual scene is clear and logical
-        if 'visual scene' in prompt_lower:
-            # Make sure scene description is coherent
-            if 'psychological angle' in prompt_lower:
-                # These are fine - they provide context
-                pass
-        
-        # Remove confusing conditional text that might create illogical images
-        # Example: "if text overlay is enabled" - simplify
-        prompt = re.sub(
-            r'if text overlay is enabled',
-            'if text is included',
-            prompt,
-            flags=re.IGNORECASE
-        )
-        prompt = re.sub(
-            r'if including text',
-            'if text is included',
-            prompt,
-            flags=re.IGNORECASE
-        )
+        # =====================================================================
+        # 8. ADD AFFILIATE MARKETING QUALITY MARKERS
+        # =====================================================================
         
-        # Ensure the prompt ends with a clear, logical instruction
-        if not prompt.strip().endswith('.'):
-            prompt += "\n\nCreate a natural, authentic, and logically coherent image. All elements should fit together naturally and make visual sense."
-        
-        # Final cleanup: remove any remaining confusing meta-text
-        prompt = prompt.replace('(OPTIONAL - ', '(')
-        prompt = prompt.replace('(for model, not to display)', '')
-        prompt = prompt.replace('(apply these, don\'t display)', '')
-        
-        # Ensure no empty sections
-        sections = prompt.split('===')
-        final_sections = []
-        for section in sections:
-            section = section.strip()
-            if section and len(section) > 10:  # Only keep substantial sections
-                final_sections.append(section)
-        prompt = '==='.join(final_sections)
-        
-        # Final validation: ensure the prompt makes logical sense
-        # Check that we're not asking for impossible combinations
-        if 'no text' in prompt_lower and 'headline' in prompt_lower:
-            # Remove headline references if we explicitly said no text
-            prompt = re.sub(
-                r'===.*HEADLINE.*===[\s\S]*?(?===|$)',
-                '',
-                prompt,
-                flags=re.IGNORECASE | re.MULTILINE
-            )
+        # Ensure the prompt has authenticity markers if not present
+        if 'authentic' not in prompt_lower and 'ugc' not in prompt_lower and 'real' not in prompt_lower:
+            prompt += "\n\nStyle: Authentic, relatable, real-person aesthetic. Not overly polished or corporate."
+        
+        # Final trim
+        prompt = prompt.strip()
         
-        return prompt.strip()
+        # Ensure prompt doesn't end mid-sentence
+        if prompt and not prompt[-1] in '.!?"\'':
+            prompt += '.'
+        
+        return prompt
     
     async def generate_ad(
         self,
@@ -2026,8 +2091,8 @@ CONCEPT: {concept['name']}
                     # Add low quality camera instruction to the prompt
                     prompt_with_camera = f"{prompt}\n\n=== CAMERA QUALITY ===\n- The image should look like it was shot from a low quality camera\n- Include characteristics of low quality camera: slight grain, reduced sharpness, lower resolution appearance, authentic camera imperfections\n- Should have the authentic feel of a real photo taken with a basic or older camera device"
                     
-                    # Refine prompt and add variation for each image
-                    base_refined_prompt = self._refine_image_prompt(prompt_with_camera)
+                    # Refine prompt and add variation for each image (pass niche for demographic fixes)
+                    base_refined_prompt = self._refine_image_prompt(prompt_with_camera, niche=niche)
                     
                     # Add variation modifier if generating multiple images
                     if num_images > 1:
@@ -2376,8 +2441,8 @@ If this image includes people or faces, they MUST look like real, original peopl
 
 Create a scroll-stopping ad image with "{headline}" prominently displayed."""
         
-        # Refine and clean the prompt before sending
-        refined_prompt = self._refine_image_prompt(prompt)
+        # Refine and clean the prompt before sending (pass niche for demographic fixes)
+        refined_prompt = self._refine_image_prompt(prompt, niche=niche)
         return refined_prompt
     
     async def generate_batch(

services/third_flow.py

@@ -487,12 +487,13 @@ CRITICAL: The image MUST show home insurance-related content. Show REAL American
         elif niche_lower == "glp1":
             niche_guidance = """
 NICHE-SPECIFIC REQUIREMENTS (GLP-1):
-SUBJECTS TO INCLUDE: confident person smiling, active lifestyle scenes, healthy meal preparation, doctor consultation
+SUBJECTS TO INCLUDE: confident person smiling (age 30-50), active lifestyle scenes with adults, healthy meal preparation, doctor consultation
 PROPS TO INCLUDE: fitness equipment, healthy food, comfortable clothing
-AVOID: before/after weight comparisons, measuring tapes, scales prominently, needle close-ups
+AVOID: before/after weight comparisons, measuring tapes, scales prominently, needle close-ups, elderly people over 65, senior citizens, very old looking people, gray-haired elderly groups
+AGE GUIDANCE: Show people aged 30-50 primarily. DO NOT default to elderly/senior citizens. The target audience is middle-aged adults in their 30s-40s, NOT seniors or elderly people.
 COLOR PREFERENCE: health
 
-CRITICAL: The image MUST be appropriate for GLP-1/weight loss niche. Show lifestyle, health, and confidence-related content, NOT home insurance content."""
+CRITICAL: The image MUST be appropriate for GLP-1/weight loss niche. Show lifestyle, health, and confidence-related content. People in images should look 30-50 years old, NOT elderly."""
         else:
             niche_guidance = f"""
 NICHE-SPECIFIC REQUIREMENTS ({niche}):
@@ -556,7 +557,10 @@ CRITICAL: The image MUST be appropriate for {niche} niche."""
             
             response = completion.choices[0].message
             if response.parsed:
-                return response.parsed.prompt
+                # Refine the prompt for affiliate marketing
+                raw_prompt = response.parsed.prompt
+                refined_prompt = self._refine_prompt_for_affiliate(raw_prompt, niche_lower)
+                return refined_prompt
             else:
                 print(f"Warning: Creative designer refusal: {response.refusal}")
                 return ""
@@ -564,6 +568,53 @@ CRITICAL: The image MUST be appropriate for {niche} niche."""
             print(f"Error in creative_designer: {e}")
             return ""
     
+    def _refine_prompt_for_affiliate(self, prompt: str, niche: str) -> str:
+        """
+        Refine GPT-generated prompt for affiliate marketing creatives.
+        Fixes illogical elements, wrong demographics, and ensures authenticity.
+        """
+        import re
+        
+        if not prompt:
+            return prompt
+        
+        prompt_lower = prompt.lower()
+        
+        # =================================================================
+        # REMOVE STOCK PHOTO / CORPORATE AESTHETICS
+        # =================================================================
+        stock_replacements = [
+            (r'\bstock photo\b', 'authentic photo'),
+            (r'\bprofessional studio shot\b', 'natural candid shot'),
+            (r'\bcorporate headshot\b', 'casual portrait'),
+            (r'\bgeneric model\b', 'real person'),
+            (r'\bperfect lighting\b', 'natural lighting'),
+            (r'\bshutterstock\b', 'authentic'),
+            (r'\bistock\b', 'documentary style'),
+        ]
+        for pattern, replacement in stock_replacements:
+            prompt = re.sub(pattern, replacement, prompt, flags=re.IGNORECASE)
+        
+        # =================================================================
+        # FIX UNREALISTIC BODY DESCRIPTIONS
+        # =================================================================
+        body_replacements = [
+            (r'\b(perfect body|flawless figure|ideal physique)\b', 'healthy confident body'),
+            (r'\b(six pack|bodybuilder|fitness model)\b', 'healthy fit person'),
+            (r'\b(impossibly thin|skeletal)\b', 'healthy'),
+        ]
+        for pattern, replacement in body_replacements:
+            prompt = re.sub(pattern, replacement, prompt, flags=re.IGNORECASE)
+        
+        # =================================================================
+        # ENSURE AUTHENTICITY FOR AFFILIATE MARKETING
+        # =================================================================
+        # Affiliate marketing principle: authentic > polished
+        if 'authentic' not in prompt_lower and 'ugc' not in prompt_lower:
+            prompt += " Authentic, relatable style - not overly polished or commercial."
+        
+        return prompt.strip()
+    
     def copy_writer(self, creative_strategy: CreativeStrategies) -> CopyWriterOutput:
         """
         Generate ad copy from creative strategy.