Update ad generation features and enhance user input options

- Renamed project references from Ad Generator Lite to PsyAdGenesis, reflecting the new branding.
- Added optional fields for target audience and offer in ad generation requests to improve customization.
- Enhanced the GeneratePage and BatchForm components to include input fields for target audience and offer.
- Updated API endpoints to handle new parameters for ad generation and batch processing.
- Improved error handling and validation for new input fields to ensure robust user experience.
- Enhanced the ad creative generation logic to incorporate user-defined target audience and offer in the output.

Ad_Generator_Lite.postman_collection.json

@@ -1,10 +1,10 @@
 {
 	"info": {
-		"_postman_id": "ad-generator-lite-collection",
-		"name": "Ad Generator Lite API",
-		"description": "Complete API collection for Ad Generator Lite - Generate high-converting ad creatives for Home Insurance and GLP-1 niches",
+		"_postman_id": "psyadgenesis-collection",
+		"name": "PsyAdGenesis API",
+		"description": "Complete API collection for PsyAdGenesis - Design ads that stop the scroll. Generate high-converting ad creatives for Home Insurance and GLP-1 niches",
 		"schema": "https://schema.getpostman.com/json/collection/v2.1.0/collection.json",
-		"_exporter_id": "ad-generator-lite"
+		"_exporter_id": "psyadgenesis"
 	},
 	"item": [
 		{

README.md

@@ -18,7 +18,7 @@ Generate high-converting ad creatives for Home Insurance and GLP-1 niches using
 ## Features
 
 - **Multiple Generation Modes**:
-  - Standard generation with randomization
+  - Standard generation using random angle × concept combinations
   - Batch generation for multiple ads
   - Angle × Concept matrix system (100 angles × 100 concepts)
   - Extensive generation with researcher → creative director → designer → copywriter flow
@@ -189,11 +189,14 @@ https://your-username-psyadgenesis.hf.space
 
 ## Matrix System
 
-The app includes a systematic Angle × Concept matrix:
+The app uses a systematic Angle × Concept matrix for all ad generation:
 - **100 Angles**: Psychological triggers (10 categories)
 - **100 Concepts**: Visual approaches (10 categories)
 - **10,000 possible combinations**
 
+**Standard Generation**: Randomly selects an angle × concept combination for each ad
+**Matrix Generation**: Allows explicit selection of specific angle × concept combinations
+
 Formula: 1 Offer → 5-8 Angles → 3-5 Concepts per angle
 
 ## License

data/glp1.py

@@ -666,6 +666,314 @@ CTAS = [
     "See Real Results",
 ]
 
+# ============================================================================
+# SECTION 3: VISUAL LIBRARY - Category Entry Points & Psychological Moments
+# Based on DirectMeds Marketing Brief: 7 Ws, CEPs, Life-Force 8, Stage of Awareness
+# ============================================================================
+
+# High-Priority Category Entry Points (CEPs)
+DIET_FATIGUE_VISUALS = [
+    "exhausted person looking at calendar, Monday marked",
+    "pile of diet books and unused meal prep containers",
+    "frustrated person deleting calorie tracking app",
+    "empty gym at 5am, abandoned exercise equipment",
+    "kitchen counter with half-finished meal prep",
+    "person crumpling up diet plan, defeated expression",
+    "calendar showing Monday starts and Friday failures",
+    "discarded diet supplements and meal replacement bars",
+    "person standing at fridge late night, exhausted",
+    "workout clothes hanging unused in closet",
+]
+
+CLOTHES_BODY_AWARENESS_VISUALS = [
+    "person standing in closet, three pairs of jeans on floor",
+    "mirror reflection, person trying on old goal-weight clothes",
+    "tight jeans with tag showing larger size",
+    "full-length mirror, person examining side profile",
+    "closet with 'goal' clothes on separate hanger",
+    "person looking down at clothes that don't fit",
+    "dressing room mirror, person holding up too-small clothing",
+    "closet full of clothes with only a few that fit",
+    "person avoiding full-length mirror in bedroom",
+    "baggy clothes hanging to hide body shape",
+]
+
+HEALTH_WAKE_UP_CALLS_VISUALS = [
+    "person reading lab results with concerned expression",
+    "doctor pointing at health chart during consultation",
+    "blood pressure monitor showing elevated numbers",
+    "person holding prescription slip, thoughtful expression",
+    "health screening results with warning indicators",
+    "person looking at scale reading with worried face",
+    "medical chart with circled high numbers",
+    "person in doctor's office reviewing test results",
+    "health app showing concerning metrics",
+    "person receiving health warning notification on phone",
+]
+
+MENTAL_LOAD_FOOD_NOISE_VISUALS = [
+    "person staring at fridge, overwhelmed by food choices",
+    "kitchen with multiple diet plans and tracking apps open",
+    "person scrolling through food tracking apps late at night",
+    "notepad with food thoughts and meal planning stress",
+    "person at grocery store looking overwhelmed by options",
+    "multiple calorie tracking apps on phone screen",
+    "person with hand on forehead, thinking about food",
+    "kitchen counter cluttered with meal planning materials",
+    "person researching food constantly on phone",
+    "mental exhaustion from constant diet decision-making",
+]
+
+# Life-Force 8 Desires
+SURVIVAL_LIFE_EXTENSION_VISUALS = [
+    "person looking at family photos, wanting to be healthier",
+    "health chart showing reduced risk after weight loss",
+    "person exercising with improved energy and mobility",
+    "doctor explaining health benefits of weight management",
+    "person feeling stronger and more capable in daily life",
+    "family members looking relieved at improved health",
+    "person reviewing long-term health benefits",
+    "active lifestyle showing increased longevity potential",
+    "person with improved lab results and health metrics",
+    "future-focused visualization of healthy aging",
+]
+
+FREEDOM_FROM_FEAR_PAIN_VISUALS = [
+    "person looking relieved after doctor's positive report",
+    "calm expression after receiving health reassurance",
+    "person feeling confident about future health outcomes",
+    "relief from constant health anxiety",
+    "peaceful moment after health scare resolution",
+    "person feeling secure about health trajectory",
+    "worried expression transforming to calm relief",
+    "person feeling protected from health risks",
+    "anxiety-free moment after taking health action",
+    "person sleeping peacefully, no longer worried about health",
+]
+
+SEXUAL_COMPANIONSHIP_VISUALS = [
+    "confident person smiling, feeling attractive",
+    "person feeling good in their own skin",
+    "couple showing affection, both feeling confident",
+    "person with renewed self-esteem and body confidence",
+    "intimate moment showing increased confidence",
+    "person looking in mirror with self-love",
+    "couple enjoying active lifestyle together",
+    "person feeling attractive and desirable",
+    "confidence boost from improved body image",
+    "person radiating self-confidence and attractiveness",
+]
+
+COMFORTABLE_LIVING_VISUALS = [
+    "person moving easily and comfortably through daily activities",
+    "comfortable seating, person feeling at ease in their body",
+    "person walking confidently without physical discomfort",
+    "daily tasks performed with ease and comfort",
+    "person feeling comfortable in public settings",
+    "relaxed moment showing physical comfort",
+    "person enjoying activities without physical limitations",
+    "comfortable mobility in everyday situations",
+    "person feeling at ease in their own skin",
+    "daily life with improved physical comfort and ease",
+]
+
+SUPERIORITY_WINNING_VISUALS = [
+    "person celebrating weight loss success story",
+    "transformation reveal to friends and family",
+    "person feeling like a success story",
+    "achievement moment showing weight loss victory",
+    "person being recognized for their transformation",
+    "success story shared on social media",
+    "person feeling like they've won and succeeded",
+    "achievement badge or milestone celebration",
+    "person feeling superior and accomplished",
+    "social proof moment showing transformation success",
+]
+
+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 gathering, person wanting to be present",
+    "person thinking about being there for grandchildren",
+    "family photo showing importance of being healthy",
+    "person making health decisions for loved ones",
+    "family support showing in health journey",
+    "person feeling responsibility to stay healthy",
+    "intergenerational moment showing health importance",
+]
+
+SOCIAL_APPROVAL_VISUALS = [
+    "person revealing transformation to amazed friends",
+    "social media post showing positive reactions",
+    "compliments from others on transformation",
+    "person receiving recognition and approval",
+    "social gathering with positive attention",
+    "transformation reveal moment with shocked reactions",
+    "person feeling accepted and approved of",
+    "social validation from weight loss success",
+    "person receiving praise and positive feedback",
+    "recognition moment showing social approval",
+]
+
+# 7 Ws-Based Moments
+WHY_MOMENT_VISUALS = [
+    "person stepping on scale, seeing disappointing number",
+    "unflattering photo that triggers desire to change",
+    "clothes that don't fit triggering frustration",
+    "doctor's warning creating urgency to act",
+    "lab results showing concerning health metrics",
+    "mirror reflection showing unwanted change",
+    "photo comparison showing weight gain over time",
+    "health scare moment creating motivation",
+    "social event where person feels uncomfortable",
+    "realization moment triggering desire for change",
+]
+
+WHEN_MOMENT_VISUALS = [
+    "person stepping on scale in morning",
+    "person seeing unflattering photo from recent event",
+    "person trying on clothes that used to fit",
+    "person receiving doctor's warning or lab results",
+    "new year resolution moment of determination",
+    "summer approaching creating urgency to change",
+    "person packing for trip, clothes don't fit",
+    "person reviewing photos from recent vacation",
+    "seasonal change triggering health focus",
+    "milestone event creating motivation to change",
+]
+
+WHERE_MOMENT_VISUALS = [
+    "person in front of mirror at home",
+    "person in closet trying on clothes",
+    "person at gym feeling discouraged",
+    "person at doctor's office reviewing health",
+    "person on couch scrolling social media",
+    "person in grocery store feeling overwhelmed",
+    "person at social event feeling self-conscious",
+    "person packing suitcase, clothes don't fit",
+    "person in bathroom with scale",
+    "person in car researching solutions on phone",
+]
+
+WITH_WHOM_VISUALS = [
+    "person alone researching weight loss solutions",
+    "person with partner discussing health goals",
+    "person with friends talking about weight loss",
+    "person with doctor receiving health guidance",
+    "person with other parents discussing health",
+    "person with coworkers comparing routines",
+    "person in online community sharing experiences",
+    "person with family supporting health journey",
+    "person with healthcare provider discussing options",
+    "person with accountability partner or support group",
+]
+
+WITH_WHAT_ACTIVITY_VISUALS = [
+    "person dieting, attempting another reset",
+    "person exercising inconsistently, feeling frustrated",
+    "person tracking calories or macros obsessively",
+    "person scrolling social media for solutions",
+    "person reading reviews or forum discussions",
+    "person watching transformation videos",
+    "person meal prepping with difficulty",
+    "person trying supplements that don't work",
+    "person researching prescription options",
+    "person comparing different weight loss programs",
+]
+
+WHILE_WEARING_USING_VISUALS = [
+    "person wearing tight or uncomfortable clothing",
+    "person trying on old goal-weight clothes",
+    "person in gym wear, feeling discouraged",
+    "person in pajamas researching late at night",
+    "person using smartwatch tracking activity",
+    "person using food tracking app on phone",
+    "person standing on bathroom scale",
+    "person taking mirror selfie, not satisfied",
+    "person wearing clothes that hide body",
+    "person using health monitoring devices",
+]
+
+WHILE_FEELING_VISUALS = [
+    "person showing frustrated expression",
+    "person looking defeated and tired",
+    "person feeling hopeful but skeptical",
+    "person looking embarrassed or self-conscious",
+    "person feeling motivated but overwhelmed",
+    "person showing anxiety about health",
+    "person tired of starting over repeatedly",
+    "person ready for real help and solutions",
+    "person feeling relieved to find legitimate option",
+    "person feeling determined and ready to change",
+]
+
+# Stage of Awareness
+UNAWARE_VISUALS = [
+    "educational moment introducing health possibilities",
+    "person discovering new health perspectives",
+    "curiosity creation about weight loss options",
+    "person learning about health risks",
+    "awareness-building moment about weight and health",
+    "person opening eyes to new possibilities",
+    "educational content sparking interest",
+    "person becoming aware of health connections",
+    "learning moment about weight loss science",
+    "person discovering weight affects health",
+]
+
+PROBLEM_AWARE_VISUALS = [
+    "person recognizing weight as a problem",
+    "person acknowledging health concerns",
+    "person realizing need for solution",
+    "person actively looking for answers",
+    "person recognizing impact of weight on life",
+    "person admitting frustration with situation",
+    "person aware of problem but seeking solution",
+    "person recognizing need for change",
+    "person acknowledging weight loss struggles",
+    "person aware of health implications",
+]
+
+SOLUTION_AWARE_VISUALS = [
+    "person discovering weight loss solutions",
+    "person comparing different solution options",
+    "person learning about prescription options",
+    "person researching effective methods",
+    "person exploring available solutions",
+    "person evaluating different approaches",
+    "person discovering GLP-1 medications",
+    "person learning about medical weight loss",
+    "person comparing solution effectiveness",
+    "person discovering legitimate options",
+]
+
+PRODUCT_AWARE_VISUALS = [
+    "person considering GLP-1 prescription option",
+    "person evaluating product benefits and value",
+    "person reviewing product information",
+    "person comparing products and providers",
+    "person looking at pricing and options",
+    "person considering specific medication",
+    "person reviewing provider credentials",
+    "person evaluating product effectiveness",
+    "person considering commitment and cost",
+    "person near decision point about product",
+]
+
+MOST_AWARE_VISUALS = [
+    "person ready to purchase, finalizing decision",
+    "person completing qualification or quiz",
+    "person ready to start transformation journey",
+    "person feeling urgency to begin",
+    "person ready to take action",
+    "person committing to health journey",
+    "person ready for prescription and start",
+    "person feeling confident in decision",
+    "person ready to make purchase",
+    "person at final step before starting",
+]
+
 
 def get_niche_data():
     """Return all GLP-1 data for the generator."""

frontend/README.md

@@ -92,9 +92,9 @@ The frontend integrates with the FastAPI backend. All API endpoints are defined
 - Quick action buttons
 
 ### Generation
-- **Single**: Generate one ad with configurable image count
-- **Batch**: Generate multiple ads (1-20) with 1-3 images each
-- **Matrix**: Select specific angle and concept combinations
+- **Single**: Generate one ad using a random angle × concept combination with configurable image count
+- **Batch**: Generate multiple ads (1-20) with 1-3 images each, each using random angle × concept combinations
+- **Matrix**: Select specific angle and concept combinations for targeted generation
 
 ### Gallery
 - Grid view of all ads

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

@@ -10,9 +10,10 @@ 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 } from "lucide-react";
+import { ArrowLeft, ArrowRight, Download, Copy, Trash2, FileJson, Wand2, History, RotateCcw, ChevronDown, ChevronUp, Edit3 } from "lucide-react";
 import type { AdCreativeDB, ImageCorrectResponse } from "@/types/api";
 import { CorrectionModal } from "@/components/generation/CorrectionModal";
+import { EditCopyModal } from "@/components/generation/EditCopyModal";
 
 export default function AdDetailPage() {
   const params = useParams();
@@ -26,6 +27,14 @@ export default function AdDetailPage() {
   const [allAds, setAllAds] = useState<AdCreativeDB[]>([]);
   const [currentIndex, setCurrentIndex] = useState<number>(-1);
   const [showCorrectionModal, setShowCorrectionModal] = useState(false);
+  const [showingOriginal, setShowingOriginal] = useState(false);
+  const [isBodyStoryExpanded, setIsBodyStoryExpanded] = useState(false);
+  const [editModal, setEditModal] = useState<{
+    isOpen: boolean;
+    field: "title" | "headline" | "primary_text" | "description" | "body_story" | "cta";
+    fieldLabel: string;
+    currentValue: string;
+  } | null>(null);
 
   useEffect(() => {
     loadAd();
@@ -34,8 +43,19 @@ export default function AdDetailPage() {
 
   useEffect(() => {
     if (ad) {
-      const { primary, fallback } = getImageUrlFallback(ad.image_url, ad.image_filename);
-      setImageSrc(primary || fallback);
+      // Check if we should show original image
+      if (showingOriginal && ad.metadata) {
+        // Prefer original_r2_url if available, otherwise use original_image_url
+        const originalUrl = ad.metadata.original_r2_url || ad.metadata.original_image_url;
+        if (originalUrl) {
+          setImageSrc(originalUrl);
+        } else {
+          setImageSrc(null);
+        }
+      } else {
+        const { primary, fallback } = getImageUrlFallback(ad.r2_url || ad.image_url, ad.image_filename);
+        setImageSrc(primary || fallback);
+      }
       setImageError(false);
       const index = allAds.findIndex((a) => a.id === ad.id);
       setCurrentIndex(index);
@@ -43,7 +63,7 @@ export default function AdDetailPage() {
       setImageSrc(null);
       setImageError(false);
     }
-  }, [ad, allAds]);
+  }, [ad, allAds, showingOriginal]);
 
   const navigateToPrevious = useCallback(() => {
     if (currentIndex > 0 && allAds.length > 0) {
@@ -113,16 +133,35 @@ export default function AdDetailPage() {
   };
 
   const handleDownloadImage = async () => {
-    if (!ad?.image_url && !ad?.image_filename) {
+    if (!ad) {
       toast.error("No image available");
       return;
     }
+    
     try {
-      const imageUrl = getImageUrl(ad.image_url, ad.image_filename);
-      if (imageUrl) {
-        await downloadImage(imageUrl, ad.image_filename || `ad-${ad.id}.png`);
-        toast.success("Image downloaded");
+      let imageUrl: string | null = null;
+      let filename: string | null = null;
+      
+      // Download the currently displayed image (original or corrected)
+      if (showingOriginal && ad.metadata) {
+        // Download original image
+        imageUrl = ad.metadata.original_r2_url || ad.metadata.original_image_url || null;
+        filename = ad.metadata.original_image_filename || `original-${ad.id}.png`;
+      } else {
+        // Download corrected/current image
+        const { primary } = getImageUrlFallback(ad.r2_url || ad.image_url, ad.image_filename);
+        imageUrl = primary || null;
+        filename = ad.image_filename || `ad-${ad.id}.png`;
+      }
+      
+      if (!imageUrl && !ad.id) {
+        toast.error("No image available");
+        return;
       }
+      
+      // Use proxy endpoint with ad ID to avoid CORS issues
+      await downloadImage(imageUrl, filename, ad.id);
+      toast.success(`Image downloaded${showingOriginal ? " (original)" : ""}`);
     } catch (error) {
       toast.error("Failed to download image");
     }
@@ -275,13 +314,35 @@ export default function AdDetailPage() {
           {/* Left - Image */}
           <div className="space-y-4">
             {imageSrc ? (
-              <div className="bg-white rounded-2xl shadow-lg shadow-blue-100/50 overflow-hidden ring-1 ring-blue-100">
+              <div className="bg-white rounded-2xl shadow-lg shadow-blue-100/50 overflow-hidden ring-1 ring-blue-100 relative">
                 <img
                   src={imageSrc}
                   alt={ad.headline}
                   className="w-full h-auto"
                   onError={handleImageError}
                 />
+                {/* Toggle button for viewing original image - only show if original image exists */}
+                {(ad.metadata?.original_image_url || ad.metadata?.original_r2_url) && (
+                  <div className="absolute top-4 right-4 z-10">
+                    <button
+                      onClick={() => setShowingOriginal(!showingOriginal)}
+                      className="group relative bg-white/80 backdrop-blur-lg hover:bg-white/95 shadow-lg hover:shadow-xl border border-white/50 rounded-full px-4 py-2.5 transition-all duration-300 flex items-center gap-2 text-sm font-medium text-gray-700 hover:text-gray-900"
+                      title={showingOriginal ? "Show current version" : "Show original version"}
+                    >
+                      <div className="relative">
+                        {showingOriginal ? (
+                          <RotateCcw className="h-4 w-4 text-blue-600 group-hover:text-blue-700 transition-colors" />
+                        ) : (
+                          <History className="h-4 w-4 text-amber-600 group-hover:text-amber-700 transition-colors" />
+                        )}
+                      </div>
+                      <span className="text-xs font-semibold">
+                        {showingOriginal ? "Current" : "Original"}
+                      </span>
+                      <div className="absolute inset-0 rounded-full bg-gradient-to-r from-blue-500/0 via-blue-500/0 to-blue-500/0 group-hover:from-blue-500/5 group-hover:via-blue-500/10 group-hover:to-blue-500/5 transition-all duration-300 -z-10" />
+                    </button>
+                  </div>
+                )}
               </div>
             ) : (
               <div className="bg-gradient-to-br from-blue-50 to-cyan-50 rounded-2xl shadow-lg aspect-square flex items-center justify-center ring-1 ring-blue-100">
@@ -338,50 +399,76 @@ export default function AdDetailPage() {
 
           {/* Right - Ad Copy */}
           <div className="space-y-5">
-            {/* Headline */}
+            {/* Title */}
             <div className="bg-white rounded-2xl shadow-lg shadow-blue-100/30 p-6 border-l-4 border-blue-500">
-              <div className="flex items-start justify-between gap-4">
-                <div className="flex-1">
-                  {ad.title && (
-                    <p className="text-sm text-blue-600 font-medium mb-1">{ad.title}</p>
-                  )}
-                  <h1 className="text-2xl font-bold bg-gradient-to-r from-gray-900 to-gray-700 bg-clip-text text-transparent leading-tight">
-                    {ad.headline}
-                  </h1>
-                </div>
-                <div className="relative group shrink-0">
+              <div className="flex items-start justify-between gap-4 mb-3">
+                <h3 className="text-xs font-bold text-blue-600 uppercase tracking-wider">Title</h3>
+                <div className="flex items-center gap-1">
                   <Button
                     variant="ghost"
                     size="sm"
-                    onClick={() => handleCopyText(ad.headline, "Headline")}
-                    className="text-blue-500 hover:bg-blue-50"
+                    onClick={() => setEditModal({
+                      isOpen: true,
+                      field: "headline",
+                      fieldLabel: "Title",
+                      currentValue: ad.headline,
+                    })}
+                    className="h-6 w-6 p-0 text-blue-500 hover:bg-blue-50"
                   >
-                    <Copy className="h-4 w-4" />
+                    <Edit3 className="h-3 w-3" />
                   </Button>
-                  <span className="absolute -bottom-8 left-1/2 -translate-x-1/2 px-2 py-1 bg-blue-600 text-white text-xs rounded opacity-0 group-hover:opacity-100 transition-opacity whitespace-nowrap pointer-events-none z-10">
-                    Copy Headline
-                  </span>
+                  <div className="relative group">
+                    <Button
+                      variant="ghost"
+                      size="sm"
+                      onClick={() => handleCopyText(ad.headline, "Title")}
+                      className="text-blue-500 hover:bg-blue-50"
+                    >
+                      <Copy className="h-4 w-4" />
+                    </Button>
+                    <span className="absolute -bottom-8 left-1/2 -translate-x-1/2 px-2 py-1 bg-blue-600 text-white text-xs rounded opacity-0 group-hover:opacity-100 transition-opacity whitespace-nowrap pointer-events-none z-10">
+                      Copy Title
+                    </span>
+                  </div>
                 </div>
               </div>
-              </div>
+              <h1 className="text-2xl font-bold bg-gradient-to-r from-gray-900 to-gray-700 bg-clip-text text-transparent leading-tight">
+                {ad.headline}
+              </h1>
+            </div>
 
             {/* Description */}
               {ad.description && (
               <div className="bg-white rounded-2xl shadow-md p-6 border-l-4 border-violet-500">
                 <div className="flex items-start justify-between gap-4 mb-3">
                   <h3 className="text-xs font-bold text-violet-600 uppercase tracking-wider">Description</h3>
-                  <div className="relative group">
+                  <div className="flex items-center gap-1">
                     <Button
                       variant="ghost"
                       size="sm"
-                      onClick={() => handleCopyText(ad.description!, "Description")}
-                      className="text-violet-500 hover:bg-violet-50"
+                      onClick={() => setEditModal({
+                        isOpen: true,
+                        field: "description",
+                        fieldLabel: "Description",
+                        currentValue: ad.description || "",
+                      })}
+                      className="h-6 w-6 p-0 text-violet-500 hover:bg-violet-50"
                     >
-                      <Copy className="h-4 w-4" />
+                      <Edit3 className="h-3 w-3" />
                     </Button>
-                    <span className="absolute -bottom-8 left-1/2 -translate-x-1/2 px-2 py-1 bg-violet-600 text-white text-xs rounded opacity-0 group-hover:opacity-100 transition-opacity whitespace-nowrap pointer-events-none z-10">
-                      Copy Description
-                    </span>
+                    <div className="relative group">
+                      <Button
+                        variant="ghost"
+                        size="sm"
+                        onClick={() => handleCopyText(ad.description!, "Description")}
+                        className="text-violet-500 hover:bg-violet-50"
+                      >
+                        <Copy className="h-4 w-4" />
+                      </Button>
+                      <span className="absolute -bottom-8 left-1/2 -translate-x-1/2 px-2 py-1 bg-violet-600 text-white text-xs rounded opacity-0 group-hover:opacity-100 transition-opacity whitespace-nowrap pointer-events-none z-10">
+                        Copy Description
+                      </span>
+                    </div>
                   </div>
                 </div>
                 <p className="text-gray-700 leading-relaxed">{ad.description}</p>
@@ -393,21 +480,62 @@ export default function AdDetailPage() {
               <div className="bg-white rounded-2xl shadow-md p-6 border-l-4 border-amber-500">
                 <div className="flex items-start justify-between gap-4 mb-3">
                   <h3 className="text-xs font-bold text-amber-600 uppercase tracking-wider">Body Story</h3>
-                  <div className="relative group">
+                  <div className="flex items-center gap-1">
                     <Button
                       variant="ghost"
                       size="sm"
-                      onClick={() => handleCopyText(ad.body_story!, "Body Story")}
-                      className="text-amber-500 hover:bg-amber-50"
+                      onClick={() => setEditModal({
+                        isOpen: true,
+                        field: "body_story",
+                        fieldLabel: "Body Story",
+                        currentValue: ad.body_story || "",
+                      })}
+                      className="h-6 w-6 p-0 text-amber-500 hover:bg-amber-50"
                     >
-                      <Copy className="h-4 w-4" />
+                      <Edit3 className="h-3 w-3" />
                     </Button>
-                    <span className="absolute -bottom-8 left-1/2 -translate-x-1/2 px-2 py-1 bg-amber-600 text-white text-xs rounded opacity-0 group-hover:opacity-100 transition-opacity whitespace-nowrap pointer-events-none z-10">
-                      Copy Story
-                    </span>
+                    <div className="relative group">
+                      <Button
+                        variant="ghost"
+                        size="sm"
+                        onClick={() => handleCopyText(ad.body_story!, "Body Story")}
+                        className="text-amber-500 hover:bg-amber-50"
+                      >
+                        <Copy className="h-4 w-4" />
+                      </Button>
+                      <span className="absolute -bottom-8 left-1/2 -translate-x-1/2 px-2 py-1 bg-amber-600 text-white text-xs rounded opacity-0 group-hover:opacity-100 transition-opacity whitespace-nowrap pointer-events-none z-10">
+                        Copy Story
+                      </span>
+                    </div>
                   </div>
                 </div>
-                <p className="text-gray-700 whitespace-pre-line leading-relaxed">{ad.body_story}</p>
+                <div className="relative">
+                  <p 
+                    className={`text-gray-700 whitespace-pre-line leading-relaxed transition-all duration-300 ${
+                      !isBodyStoryExpanded ? 'line-clamp-3' : ''
+                    }`}
+                  >
+                    {ad.body_story}
+                  </p>
+                  {ad.body_story.split('\n').length > 3 || ad.body_story.length > 200 ? (
+                    <button
+                      onClick={() => setIsBodyStoryExpanded(!isBodyStoryExpanded)}
+                      className="mt-2 flex items-center gap-1 text-amber-600 hover:text-amber-700 text-sm font-medium transition-colors"
+                    >
+                      {isBodyStoryExpanded ? (
+                        <>
+                          <span>Show less</span>
+                          <ChevronUp className="h-4 w-4" />
+                        </>
+                      ) : (
+                        <>
+                          <span>Read more</span>
+                          <ChevronDown className="h-4 w-4" />
+                        </>
+                      )}
+                    </button>
+                  ) : null}
+                </div>
               </div>
             )}
 
@@ -416,18 +544,33 @@ export default function AdDetailPage() {
               <div className="bg-gradient-to-r from-emerald-50 to-teal-50 rounded-2xl shadow-md p-6 border border-emerald-200">
                 <div className="flex items-start justify-between gap-4 mb-3">
                   <h3 className="text-xs font-bold text-emerald-600 uppercase tracking-wider">Call to Action</h3>
-                  <div className="relative group">
+                  <div className="flex items-center gap-1">
                     <Button
                       variant="ghost"
                       size="sm"
-                      onClick={() => handleCopyText(ad.cta!, "CTA")}
-                      className="text-emerald-600 hover:bg-emerald-100"
+                      onClick={() => setEditModal({
+                        isOpen: true,
+                        field: "cta",
+                        fieldLabel: "Call to Action",
+                        currentValue: ad.cta || "",
+                      })}
+                      className="h-6 w-6 p-0 text-emerald-600 hover:bg-emerald-100"
                     >
-                      <Copy className="h-4 w-4" />
+                      <Edit3 className="h-3 w-3" />
                     </Button>
-                    <span className="absolute -bottom-8 left-1/2 -translate-x-1/2 px-2 py-1 bg-emerald-600 text-white text-xs rounded opacity-0 group-hover:opacity-100 transition-opacity whitespace-nowrap pointer-events-none z-10">
-                      Copy CTA
-                    </span>
+                    <div className="relative group">
+                      <Button
+                        variant="ghost"
+                        size="sm"
+                        onClick={() => handleCopyText(ad.cta!, "CTA")}
+                        className="text-emerald-600 hover:bg-emerald-100"
+                      >
+                        <Copy className="h-4 w-4" />
+                      </Button>
+                      <span className="absolute -bottom-8 left-1/2 -translate-x-1/2 px-2 py-1 bg-emerald-600 text-white text-xs rounded opacity-0 group-hover:opacity-100 transition-opacity whitespace-nowrap pointer-events-none z-10">
+                        Copy CTA
+                      </span>
+                    </div>
                   </div>
                 </div>
                 <p className="text-xl font-bold bg-gradient-to-r from-emerald-600 to-teal-600 bg-clip-text text-transparent">{ad.cta}</p>
@@ -472,18 +615,36 @@ export default function AdDetailPage() {
         onClose={() => setShowCorrectionModal(false)}
         adId={adId}
         ad={ad}
-        onSuccess={(result: ImageCorrectResponse) => {
-          // Update the displayed image if correction was successful
-          if (result.corrected_image?.image_url) {
-            setImageSrc(result.corrected_image.image_url);
-          }
-          // If a new ad was created, optionally navigate to it or reload the gallery
-          if (result.corrected_image?.ad_id) {
-            toast.success("Corrected image saved to gallery!");
-            // Optionally: router.push(`/gallery/${result.corrected_image.ad_id}`);
+        onSuccess={async (result: ImageCorrectResponse) => {
+          // Reload the ad to get updated image and metadata
+          if (result.status === "success") {
+            toast.success("Image corrected 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 (corrected) image
+            }, 500);
           }
         }}
       />
+
+      {/* Edit Copy Modal */}
+      {editModal && ad && (
+        <EditCopyModal
+          isOpen={editModal.isOpen}
+          onClose={() => setEditModal(null)}
+          adId={adId}
+          ad={ad}
+          field={editModal.field}
+          fieldLabel={editModal.fieldLabel}
+          currentValue={editModal.currentValue}
+          onSuccess={async () => {
+            await loadAd();
+            setEditModal(null);
+          }}
+        />
+      )}
     </div>
   );
 }

frontend/app/gallery/page.tsx

@@ -98,6 +98,14 @@ export default function GalleryPage() {
       // In a production app, you'd want server-side search for accurate totals
       const total = filters.search ? filteredAds.length : response.total;
       setAds(filteredAds, total);
+      
+      // Clear selections for ads that are no longer in the current list
+      const currentAdIds = new Set(filteredAds.map(ad => ad.id));
+      const validSelections = selectedAds.filter(id => currentAdIds.has(id));
+      if (validSelections.length !== selectedAds.length) {
+        // Only update if there's a difference to avoid unnecessary re-renders
+        clearSelection();
+      }
     } catch (error: any) {
       toast.error("Failed to load ads");
       console.error(error);
@@ -110,6 +118,20 @@ export default function GalleryPage() {
     loadAds();
   }, [loadAds]);
 
+  // Clear stale selections when component mounts (selections for ads not in current list)
+  useEffect(() => {
+    if (selectedAds.length > 0 && ads.length > 0) {
+      const currentAdIds = new Set(ads.map(ad => ad.id));
+      const hasStaleSelections = selectedAds.some(id => !currentAdIds.has(id));
+      if (hasStaleSelections) {
+        clearSelection();
+      }
+    } else if (selectedAds.length > 0 && ads.length === 0) {
+      // If there are selections but no ads loaded yet, clear them
+      clearSelection();
+    }
+  }, [ads, selectedAds, clearSelection]);
+
   const handleBulkDelete = async () => {
     if (selectedAds.length === 0) return;
 
@@ -172,32 +194,31 @@ export default function GalleryPage() {
                 </>
               ) : (
                 ads.length > 0 && (
-                  <Button variant="outline" size="sm" onClick={selectAll}>
-                    <div className="flex items-center gap-2">
-                      <CheckSquare className="h-4 w-4" />
-                      <span>Select All</span>
-                    </div>
-                  </Button>
+                  <button
+                    onClick={selectAll}
+                    className="flex items-center gap-2 px-3 py-1.5 bg-gray-50 hover:bg-gray-100 border border-gray-200 rounded-lg text-sm font-medium text-gray-700 transition-colors duration-200"
+                  >
+                    <CheckSquare className="h-4 w-4" />
+                    <span>Select All</span>
+                  </button>
                 )
               )}
             </div>
             
             {/* Sort Controls */}
             {sortOptions && (
-              <Button
-                variant="outline"
-                size="sm"
+              <button
                 onClick={() => setSortOptions({ 
                   field: "created_at",
                   direction: sortOptions.direction === "desc" ? "asc" : "desc" 
                 })}
-                className="flex items-center gap-2"
+                className="flex items-center gap-2 px-3 py-1.5 bg-gray-50 hover:bg-gray-100 border border-gray-200 rounded-lg text-sm font-medium text-gray-700 transition-colors duration-200"
               >
                 <ArrowUpDown className="h-4 w-4" />
-                <span className="text-sm">
+                <span>
                   {sortOptions.direction === "desc" ? "Newest First" : "Oldest First"}
                 </span>
-              </Button>
+              </button>
             )}
           </div>
         </div>

frontend/app/generate/page.tsx

@@ -27,6 +27,8 @@ export default function GeneratePage() {
   const [niche, setNiche] = useState<Niche>("home_insurance");
   const [numImages, setNumImages] = useState(1);
   const [imageModel, setImageModel] = useState<string | null>(null);
+  const [targetAudience, setTargetAudience] = useState("");
+  const [offer, setOffer] = useState("");
   const [batchResults, setBatchResults] = useState<GenerateResponse[]>([]);
   const [currentBatchIndex, setCurrentBatchIndex] = useState(0);
   const [batchProgress, setBatchProgress] = useState(0);
@@ -73,57 +75,120 @@ export default function GeneratePage() {
     }
   }, [progress.step, currentGeneration]);
 
-  const handleStandardGenerate = async (data: { niche: Niche; num_images: number; image_model?: string | null }) => {
+  const handleStandardGenerate = async (data: { niche: Niche; num_images: number; image_model?: string | null; target_audience?: string; offer?: string }) => {
     reset();
     setIsGenerating(true);
     setGenerationStartTime(Date.now());
-    setProgress({
-      step: "copy",
-      progress: 10,
-      message: "Generating ad copy...",
-    });
+    
+    // If num_images > 1, generate batch of ads
+    if (data.num_images > 1) {
+      setBatchCount(data.num_images);
+      setBatchResults([]);
+      setCurrentBatchIndex(0);
+      setBatchProgress(0);
+      
+      setProgress({
+        step: "image",
+        progress: 0,
+        message: `Generating ${data.num_images} ads in batch...`,
+      });
 
-    try {
-      // Simulate progress updates
-      let currentProgress = 20;
-      const progressInterval = setInterval(() => {
-        currentProgress = Math.min(90, currentProgress + 5);
-        setProgress({
-          step: currentProgress < 50 ? "copy" : "image",
-          progress: currentProgress,
-          message: currentProgress < 50 ? "Generating ad copy..." : "Generating images...",
+      try {
+        // Use batch generation for multiple ads with standard method
+        const batchResponse = await generateBatch({
+          niche: data.niche,
+          count: data.num_images,
+          images_per_ad: 1, // Each ad gets 1 image
+          image_model: data.image_model,
+          method: "standard", // Use standard method only
+          target_audience: data.target_audience,
+          offer: data.offer,
         });
-      }, 1000);
+        const results = batchResponse.ads;
 
-      // Generate ad
-      const result = await generateAd(data);
+        setBatchResults(results);
+        setBatchProgress(100);
+        setProgress({
+          step: "complete",
+          progress: 100,
+          message: `Generated ${results.length} ads successfully!`,
+        });
 
-      clearInterval(progressInterval);
+        // Show first result
+        if (results.length > 0) {
+          setCurrentGeneration(results[0] as GenerateResponse);
+        }
 
+        toast.success(`Generated ${results.length} ads successfully!`);
+      } catch (error: any) {
+        setError(error.message || "Failed to generate ads");
+        setProgress({
+          step: "error",
+          progress: 0,
+          message: error.message || "An error occurred",
+        });
+        toast.error(error.message || "Failed to generate ads");
+      } finally {
+        setIsGenerating(false);
+      }
+    } else {
+      // Single ad generation - clear batch results
+      setBatchResults([]);
+      setCurrentBatchIndex(0);
+      
       setProgress({
-        step: "saving",
-        progress: 90,
-        message: "Saving to database...",
+        step: "copy",
+        progress: 10,
+        message: "Generating ad copy...",
       });
 
-      setCurrentGeneration(result);
-      setProgress({
-        step: "complete",
-        progress: 100,
-        message: "Ad generated successfully!",
-      });
+      try {
+        // Simulate progress updates
+        let currentProgress = 20;
+        const progressInterval = setInterval(() => {
+          currentProgress = Math.min(90, currentProgress + 5);
+          setProgress({
+            step: currentProgress < 50 ? "copy" : "image",
+            progress: currentProgress,
+            message: currentProgress < 50 ? "Generating ad copy..." : "Generating images...",
+          });
+        }, 1000);
+
+        // Generate single ad with 1 image
+        const result = await generateAd({
+          ...data,
+          num_images: 1,
+          target_audience: data.target_audience,
+          offer: data.offer,
+        });
 
-      toast.success("Ad generated successfully!");
-    } catch (error: any) {
-      setError(error.message || "Failed to generate ad");
-      setProgress({
-        step: "error",
-        progress: 0,
-        message: error.message || "An error occurred",
-      });
-      toast.error(error.message || "Failed to generate ad");
-    } finally {
-      setIsGenerating(false);
+        clearInterval(progressInterval);
+
+        setProgress({
+          step: "saving",
+          progress: 90,
+          message: "Saving to database...",
+        });
+
+        setCurrentGeneration(result);
+        setProgress({
+          step: "complete",
+          progress: 100,
+          message: "Ad generated successfully!",
+        });
+
+        toast.success("Ad generated successfully!");
+      } catch (error: any) {
+        setError(error.message || "Failed to generate ad");
+        setProgress({
+          step: "error",
+          progress: 0,
+          message: error.message || "An error occurred",
+        });
+        toast.error(error.message || "Failed to generate ad");
+      } finally {
+        setIsGenerating(false);
+      }
     }
   };
 
@@ -136,43 +201,106 @@ export default function GeneratePage() {
     reset();
     setIsGenerating(true);
     setGenerationStartTime(Date.now());
-    setProgress({
-      step: "copy",
-      progress: 10,
-      message: "Generating ad with selected angle and concept...",
-    });
-
-    try {
-      const result = await generateMatrixAd({
-        niche,
-        angle_key: selectedAngle.key,
-        concept_key: selectedConcept.key,
-        num_images: numImages,
-        image_model: imageModel,
-      });
 
-      setCurrentGeneration(result);
+    // If numImages > 1, generate batch of ads using matrix method
+    if (numImages > 1) {
+      setBatchCount(numImages);
+      setBatchResults([]);
+      setCurrentBatchIndex(0);
+      setBatchProgress(0);
+      
       setProgress({
-        step: "complete",
-        progress: 100,
-        message: "Ad generated successfully!",
+        step: "image",
+        progress: 0,
+        message: `Generating ${numImages} ads with matrix method...`,
       });
 
-      toast.success("Ad generated successfully!");
-    } catch (error: any) {
-      setError(error.message || "Failed to generate ad");
+      try {
+        // Generate batch using matrix method
+        const results = await Promise.all(
+          Array.from({ length: numImages }, (_, i) =>
+            generateMatrixAd({
+              niche,
+              angle_key: selectedAngle.key,
+              concept_key: selectedConcept.key,
+              num_images: 1, // Each ad gets 1 image
+              image_model: imageModel,
+              target_audience: targetAudience || undefined,
+              offer: offer || undefined,
+            })
+          )
+        );
+
+        setBatchResults(results as unknown as GenerateResponse[]);
+        setBatchProgress(100);
+        setProgress({
+          step: "complete",
+          progress: 100,
+          message: `Generated ${results.length} ads successfully!`,
+        });
+
+        // Show first result
+        if (results.length > 0) {
+          setCurrentGeneration(results[0]);
+        }
+
+        toast.success(`Generated ${results.length} ads successfully!`);
+      } catch (error: any) {
+        setError(error.message || "Failed to generate ads");
+        setProgress({
+          step: "error",
+          progress: 0,
+          message: error.message || "An error occurred",
+        });
+        toast.error(error.message || "Failed to generate ads");
+      } finally {
+        setIsGenerating(false);
+      }
+    } else {
+      // Single ad generation - clear batch results
+      setBatchResults([]);
+      setCurrentBatchIndex(0);
+      
       setProgress({
-        step: "error",
-        progress: 0,
-        message: error.message || "An error occurred",
+        step: "copy",
+        progress: 10,
+        message: "Generating ad with selected angle and concept...",
       });
-      toast.error(error.message || "Failed to generate ad");
-    } finally {
-      setIsGenerating(false);
+
+      try {
+        const result = await generateMatrixAd({
+          niche,
+          angle_key: selectedAngle.key,
+          concept_key: selectedConcept.key,
+          num_images: 1, // Single image
+          image_model: imageModel,
+          target_audience: targetAudience || undefined,
+          offer: offer || undefined,
+        });
+
+        setCurrentGeneration(result);
+        setProgress({
+          step: "complete",
+          progress: 100,
+          message: "Ad generated successfully!",
+        });
+
+        toast.success("Ad generated successfully!");
+      } catch (error: any) {
+        setError(error.message || "Failed to generate ad");
+        setProgress({
+          step: "error",
+          progress: 0,
+          message: error.message || "An error occurred",
+        });
+        toast.error(error.message || "Failed to generate ad");
+      } finally {
+        setIsGenerating(false);
+      }
     }
   };
 
-  const handleBatchGenerate = async (data: { niche: Niche; count: number; images_per_ad: number; image_model?: string | null }) => {
+  const handleBatchGenerate = async (data: { niche: Niche; count: number; images_per_ad: number; image_model?: string | null; target_audience?: string; offer?: string }) => {
     setBatchResults([]);
     setIsGenerating(true);
     setGenerationStartTime(Date.now());
@@ -205,7 +333,11 @@ export default function GeneratePage() {
     }, progressInterval);
 
     try {
-      const result = await generateBatch(data);
+      const result = await generateBatch({
+        ...data,
+        target_audience: data.target_audience,
+        offer: data.offer,
+      });
       clearInterval(progressIntervalId);
       setBatchResults(result.ads);
       setCurrentBatchIndex(data.count - 1); // Set to last ad
@@ -233,8 +365,8 @@ export default function GeneratePage() {
 
   const handleExtensiveGenerate = async (data: {
     niche: Niche;
-    target_audience: string;
-    offer: string;
+    target_audience?: string;
+    offer?: string;
     num_images: number;
     num_strategies: number;
     image_model?: string | null;
@@ -526,6 +658,32 @@ export default function GeneratePage() {
                       </select>
                     </div>
 
+                    <div>
+                      <label className="block text-sm font-semibold text-gray-700 mb-2">
+                        Target Audience
+                      </label>
+                      <input
+                        type="text"
+                        className="w-full px-4 py-3 rounded-xl border-2 border-gray-300 bg-white/80 backdrop-blur-sm focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500 transition-all duration-250"
+                        placeholder="e.g., US people over 50+ age"
+                        value={targetAudience}
+                        onChange={(e) => setTargetAudience(e.target.value)}
+                      />
+                    </div>
+
+                    <div>
+                      <label className="block text-sm font-semibold text-gray-700 mb-2">
+                        Offer
+                      </label>
+                      <input
+                        type="text"
+                        className="w-full px-4 py-3 rounded-xl border-2 border-gray-300 bg-white/80 backdrop-blur-sm focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500 transition-all duration-250"
+                        placeholder="e.g., Don't overpay your insurance"
+                        value={offer}
+                        onChange={(e) => setOffer(e.target.value)}
+                      />
+                    </div>
+
                     <div>
                       <label className="block text-sm font-semibold text-gray-700 mb-2">Image Model</label>
                       <select
@@ -543,7 +701,7 @@ export default function GeneratePage() {
 
                     <div>
                       <label className="block text-sm font-semibold text-gray-700 mb-2">
-                        Number of Variations: <span className="text-blue-600 font-bold">{numImages}</span>
+                        Number of Images: <span className="text-blue-600 font-bold">{numImages}</span>
                       </label>
                       <input
                         type="range"
@@ -559,7 +717,7 @@ export default function GeneratePage() {
                         <span>5</span>
                       </div>
                       <p className="text-xs text-gray-500 mt-1">
-                        Each variation will have a unique image and slight copy variations
+                        Generate multiple images for the same ad copy using the same method
                       </p>
                     </div>
                   </CardContent>
@@ -610,7 +768,7 @@ export default function GeneratePage() {
 
           {/* Right Column - Preview */}
           <div className="lg:col-span-2">
-            {mode === "batch" && batchResults.length > 0 ? (
+            {batchResults.length > 0 ? (
               <div className="space-y-6 animate-fade-in">
                 <div className="bg-white/80 backdrop-blur-sm rounded-2xl shadow-lg p-6 border border-gray-200">
                   <div className="flex items-center justify-between flex-wrap gap-4">

frontend/app/page.tsx

@@ -150,7 +150,7 @@ export default function Dashboard() {
   return (
     <div className="min-h-screen pb-12">
       {/* Hero Section */}
-      <div className="relative overflow-hidden bg-gradient-to-br from-blue-50 via-cyan-50 to-pink-50 py-16 mb-12">
+      <div className="relative overflow-hidden bg-gradient-to-br from-blue-50 via-cyan-50 to-pink-50 py-8 mb-8">
         <div className="absolute inset-0 bg-grid-pattern opacity-5"></div>
         <div className="max-w-7xl mx-auto px-4 sm:px-6 lg:px-8 relative z-10">
           <div className="text-center animate-fade-in">
@@ -160,9 +160,6 @@ export default function Dashboard() {
             <p className="text-xl text-gray-600 max-w-2xl mx-auto font-medium">
               Design ads that stop the scroll.
             </p>
-            <p className="text-lg text-gray-500 max-w-2xl mx-auto mt-2">
-              Generate high-converting ad creatives for Home Insurance and GLP-1 niches with AI-powered generation
-            </p>
           </div>
         </div>
       </div>

frontend/components/gallery/AdCard.tsx

@@ -5,12 +5,14 @@ import Link from "next/link";
 import Image from "next/image";
 import { Card, CardContent } from "@/components/ui/Card";
 import { formatRelativeDate, formatNiche, getImageUrl, getImageUrlFallback, truncateText } from "@/lib/utils/formatters";
+import { CheckSquare, Square } from "lucide-react";
 import type { AdCreativeDB } from "@/types/api";
 
 interface AdCardProps {
   ad: AdCreativeDB;
   isSelected?: boolean;
   onSelect?: (adId: string) => void;
+  hasAnySelection?: boolean;
 }
 
 // Reusable gradient badge component
@@ -24,6 +26,7 @@ export const AdCard: React.FC<AdCardProps> = memo(({
   ad,
   isSelected = false,
   onSelect,
+  hasAnySelection = false,
 }) => {
   const { primary, fallback } = getImageUrlFallback(ad.image_url, ad.image_filename);
   const [imageSrc, setImageSrc] = useState<string | null>(primary || fallback);
@@ -74,6 +77,29 @@ export const AdCard: React.FC<AdCardProps> = memo(({
                 </div>
               )}
               <div className="absolute inset-0 bg-gradient-to-t from-black/30 to-transparent opacity-0 group-hover:opacity-100 transition-opacity duration-300"></div>
+              {/* Selection checkbox - show on hover when nothing selected, always show when something is selected */}
+              <div className="absolute top-3 left-3 z-10">
+                <button
+                  className={`flex items-center justify-center w-6 h-6 rounded-md border-2 transition-all duration-200 ${
+                    isSelected
+                      ? "bg-blue-500 border-blue-500 text-white shadow-lg"
+                      : hasAnySelection
+                      ? "bg-white/90 backdrop-blur-sm border-gray-300 hover:border-blue-400 hover:bg-white shadow-md"
+                      : "bg-white/90 backdrop-blur-sm border-gray-300 hover:border-blue-400 hover:bg-white shadow-md opacity-0 group-hover:opacity-100"
+                  }`}
+                  onClick={(e) => {
+                    e.stopPropagation();
+                    e.preventDefault();
+                    onSelect?.(ad.id);
+                  }}
+                >
+                  {isSelected ? (
+                    <CheckSquare className="h-4 w-4" />
+                  ) : (
+                    <Square className="h-4 w-4 text-gray-400" />
+                  )}
+                </button>
+              </div>
             </div>
           )}
           <div className="p-5 flex-1 flex flex-col">
@@ -113,6 +139,7 @@ export const AdCard: React.FC<AdCardProps> = memo(({
   return (
     prevProps.ad.id === nextProps.ad.id &&
     prevProps.isSelected === nextProps.isSelected &&
+    prevProps.hasAnySelection === nextProps.hasAnySelection &&
     prevProps.ad.image_url === nextProps.ad.image_url
   );
 });

frontend/components/gallery/FilterBar.tsx

@@ -35,9 +35,9 @@ export const FilterBar: React.FC<FilterBarProps> = ({
 
   return (
     <Card variant="glass">
-      <div className="p-6 space-y-4">
+      <div className="p-3 space-y-3">
         <div className="flex items-center justify-between">
-          <h3 className="text-lg font-bold gradient-text">Filters</h3>
+          <h3 className="text-base font-bold gradient-text">Filters</h3>
           {hasActiveFilters && (
             <Button variant="ghost" size="sm" onClick={clearFilters} className="group">
               <X className="h-4 w-4 mr-1 group-hover:rotate-90 transition-transform duration-300" />
@@ -46,7 +46,7 @@ export const FilterBar: React.FC<FilterBarProps> = ({
           )}
         </div>
 
-        <div className="grid grid-cols-1 md:grid-cols-3 gap-4">
+        <div className="grid grid-cols-1 md:grid-cols-3 gap-3">
           <Input
             placeholder="Search by headline or title..."
             value={filters.search || ""}

frontend/components/gallery/GalleryGrid.tsx

@@ -35,6 +35,8 @@ export const GalleryGrid: React.FC<GalleryGridProps> = ({
     );
   }
 
+  const hasAnySelection = selectedAds.length > 0;
+
   return (
     <div className="grid grid-cols-1 md:grid-cols-2 lg:grid-cols-3 xl:grid-cols-4 gap-6">
       {ads.map((ad) => (
@@ -43,6 +45,7 @@ export const GalleryGrid: React.FC<GalleryGridProps> = ({
           ad={ad}
           isSelected={selectedAds.includes(ad.id)}
           onSelect={onAdSelect}
+          hasAnySelection={hasAnySelection}
         />
       ))}
     </div>

frontend/components/generation/AdPreview.tsx

@@ -2,7 +2,7 @@
 
 import React, { useState } from "react";
 import { Button } from "@/components/ui/Button";
-import { Download, Copy } from "lucide-react";
+import { Download, Copy, ChevronDown, ChevronUp } from "lucide-react";
 import { downloadImage, copyToClipboard } from "@/lib/utils/export";
 import { getImageUrl, getImageUrlFallback, formatRelativeDate } from "@/lib/utils/formatters";
 import { toast } from "react-hot-toast";
@@ -14,6 +14,7 @@ interface AdPreviewProps {
 
 export const AdPreview: React.FC<AdPreviewProps> = ({ ad }) => {
   const [imageErrors, setImageErrors] = useState<Record<number, boolean>>({});
+  const [isBodyStoryExpanded, setIsBodyStoryExpanded] = useState(false);
 
   // Debug: Log image details to verify uniqueness
   React.useEffect(() => {
@@ -32,17 +33,16 @@ export const AdPreview: React.FC<AdPreviewProps> = ({ ad }) => {
   }, [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) {
+    if (!imageUrl && !filename && !ad.id) {
       toast.error("No image URL available");
       return;
     }
     
     try {
       const url = getImageUrl(imageUrl, filename);
-      if (url) {
-        await downloadImage(url, filename || `ad-${ad.id}.png`);
-        toast.success("Image downloaded");
-      }
+      // Use proxy endpoint with ad ID to avoid CORS issues
+      await downloadImage(url, filename || `ad-${ad.id}.png`, ad.id);
+      toast.success("Image downloaded");
     } catch (error) {
       toast.error("Failed to download image");
     }
@@ -292,21 +292,49 @@ export const AdPreview: React.FC<AdPreviewProps> = ({ ad }) => {
             <div className="bg-white rounded-2xl shadow-md p-6 border-l-4 border-amber-500">
               <div className="flex items-start justify-between gap-4 mb-3">
                 <h3 className="text-xs font-bold text-amber-600 uppercase tracking-wider">Body Story</h3>
-                <div className="relative group">
-                  <Button
-                    variant="ghost"
-                    size="sm"
-                    onClick={() => handleCopyText(ad.body_story!, "Body Story")}
-                    className="text-amber-500 hover:bg-amber-50"
-                  >
-                    <Copy className="h-4 w-4" />
-                  </Button>
-                  <span className="absolute -bottom-8 left-1/2 -translate-x-1/2 px-2 py-1 bg-amber-600 text-white text-xs rounded opacity-0 group-hover:opacity-100 transition-opacity whitespace-nowrap pointer-events-none z-10">
-                    Copy Story
-                  </span>
+                <div className="flex items-center gap-2">
+                  <div className="relative group">
+                    <Button
+                      variant="ghost"
+                      size="sm"
+                      onClick={() => handleCopyText(ad.body_story!, "Body Story")}
+                      className="text-amber-500 hover:bg-amber-50"
+                    >
+                      <Copy className="h-4 w-4" />
+                    </Button>
+                    <span className="absolute -bottom-8 left-1/2 -translate-x-1/2 px-2 py-1 bg-amber-600 text-white text-xs rounded opacity-0 group-hover:opacity-100 transition-opacity whitespace-nowrap pointer-events-none z-10">
+                      Copy Story
+                    </span>
+                  </div>
                 </div>
               </div>
-              <p className="text-gray-700 whitespace-pre-line leading-relaxed">{ad.body_story}</p>
+              <div className="relative">
+                <p 
+                  className={`text-gray-700 whitespace-pre-line leading-relaxed transition-all duration-300 ${
+                    !isBodyStoryExpanded ? 'line-clamp-3' : ''
+                  }`}
+                >
+                  {ad.body_story}
+                </p>
+                {ad.body_story.split('\n').length > 3 || ad.body_story.length > 200 ? (
+                  <button
+                    onClick={() => setIsBodyStoryExpanded(!isBodyStoryExpanded)}
+                    className="mt-2 flex items-center gap-1 text-amber-600 hover:text-amber-700 text-sm font-medium transition-colors"
+                  >
+                    {isBodyStoryExpanded ? (
+                      <>
+                        <span>Show less</span>
+                        <ChevronUp className="h-4 w-4" />
+                      </>
+                    ) : (
+                      <>
+                        <span>Read more</span>
+                        <ChevronDown className="h-4 w-4" />
+                      </>
+                    )}
+                  </button>
+                ) : null}
+              </div>
             </div>
           )}
 

frontend/components/generation/BatchForm.tsx

@@ -12,7 +12,7 @@ import { IMAGE_MODELS } from "@/lib/constants/models";
 import type { Niche } from "@/types/api";
 
 interface BatchFormProps {
-  onSubmit: (data: { niche: Niche; count: number; images_per_ad: number; image_model?: string | null }) => Promise<void>;
+  onSubmit: (data: { niche: Niche; count: number; images_per_ad: number; image_model?: string | null; target_audience?: string; offer?: string }) => Promise<void>;
   isLoading: boolean;
 }
 
@@ -32,6 +32,8 @@ export const BatchForm: React.FC<BatchFormProps> = ({
       count: 5,
       images_per_ad: 1,
       image_model: null,
+      target_audience: "",
+      offer: "",
     },
   });
 
@@ -58,6 +60,36 @@ export const BatchForm: React.FC<BatchFormProps> = ({
             {...register("niche")}
           />
 
+          <div>
+            <label className="block text-sm font-semibold text-gray-700 mb-2">
+              Target Audience
+            </label>
+            <input
+              type="text"
+              className="w-full px-4 py-3 rounded-xl border-2 border-gray-300 bg-white/80 backdrop-blur-sm focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500 transition-all duration-250"
+              placeholder="e.g., US people over 50+ age"
+              {...register("target_audience")}
+            />
+            {errors.target_audience && (
+              <p className="text-red-500 text-xs mt-1">{errors.target_audience.message}</p>
+            )}
+          </div>
+
+          <div>
+            <label className="block text-sm font-semibold text-gray-700 mb-2">
+              Offer
+            </label>
+            <input
+              type="text"
+              className="w-full px-4 py-3 rounded-xl border-2 border-gray-300 bg-white/80 backdrop-blur-sm focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500 transition-all duration-250"
+              placeholder="e.g., Don't overpay your insurance"
+              {...register("offer")}
+            />
+            {errors.offer && (
+              <p className="text-red-500 text-xs mt-1">{errors.offer.message}</p>
+            )}
+          </div>
+
           <Select
             label="Image Model"
             options={IMAGE_MODELS.map(model => ({ value: model.value, label: model.label }))}

frontend/components/generation/CorrectionModal.tsx

@@ -96,7 +96,8 @@ export const CorrectionModal: React.FC<CorrectionModalProps> = ({
       if (response.status === "success") {
         setStep("complete");
         setResult(response);
-        onSuccess?.(response);
+        // Don't call onSuccess immediately - let user see the corrections first
+        // onSuccess will be called when user clicks "Done"
       } else {
         setStep("error");
         setError(response.error || "Correction failed");
@@ -211,13 +212,6 @@ export const CorrectionModal: React.FC<CorrectionModalProps> = ({
                         <p>AI will analyze the image for spelling mistakes and visual issues, then suggest corrections.</p>
                       </div>
                     )}
-
-                    {userInstructions && (
-                      <div className="bg-green-50 border border-green-200 rounded-lg p-3 text-sm text-green-800">
-                        <p className="font-semibold mb-1">Custom Correction Mode</p>
-                        <p>Only the changes you specified will be made. The rest of the image will be preserved.</p>
-                      </div>
-                    )}
                   </div>
                 </CardContent>
               </Card>
@@ -274,46 +268,90 @@ export const CorrectionModal: React.FC<CorrectionModalProps> = ({
                 </div>
               )}
 
+              {/* Show corrections details */}
               {result.corrections && (
-                <div className="space-y-3">
-                  {result.corrections.spelling_corrections.length > 0 && (
+                <div className="space-y-4">
+                  <h3 className="font-semibold text-gray-900 text-lg">Correction Details</h3>
+                  
+                  {result.corrections.spelling_corrections && result.corrections.spelling_corrections.length > 0 && (
                     <div>
-                      <h3 className="font-semibold text-gray-900 mb-2">Spelling Corrections</h3>
+                      <h4 className="font-semibold text-gray-900 mb-2 flex items-center gap-2">
+                        <span className="text-yellow-600">✏️</span>
+                        Spelling Corrections
+                      </h4>
                       <div className="space-y-2">
                         {result.corrections.spelling_corrections.map((correction, idx) => (
                           <div
                             key={idx}
                             className="bg-yellow-50 border border-yellow-200 rounded-lg p-3 text-sm"
                           >
-                            <span className="font-medium text-red-600 line-through">
-                              {correction.detected}
-                            </span>{" "}
-                            →{" "}
-                            <span className="font-medium text-green-600">
-                              {correction.corrected}
-                            </span>
+                            <div className="flex items-center gap-2">
+                              <span className="font-medium text-red-600 line-through">
+                                {correction.detected}
+                              </span>
+                              <span className="text-gray-400">→</span>
+                              <span className="font-medium text-green-600">
+                                {correction.corrected}
+                              </span>
+                            </div>
+                            {correction.context && (
+                              <p className="text-xs text-gray-500 mt-1 italic">{correction.context}</p>
+                            )}
                           </div>
                         ))}
                       </div>
                     </div>
                   )}
 
-                  {result.corrections.visual_corrections.length > 0 && (
+                  {result.corrections.visual_corrections && result.corrections.visual_corrections.length > 0 && (
                     <div>
-                      <h3 className="font-semibold text-gray-900 mb-2">Visual Improvements</h3>
+                      <h4 className="font-semibold text-gray-900 mb-2 flex items-center gap-2">
+                        <span className="text-blue-600">🎨</span>
+                        Visual Improvements
+                      </h4>
                       <div className="space-y-2">
                         {result.corrections.visual_corrections.map((correction, idx) => (
                           <div
                             key={idx}
                             className="bg-blue-50 border border-blue-200 rounded-lg p-3 text-sm"
                           >
-                            <p className="font-medium text-gray-900">{correction.issue}</p>
-                            <p className="text-gray-600 mt-1">{correction.suggestion}</p>
+                            <div className="flex items-start justify-between gap-2">
+                              <div className="flex-1">
+                                <p className="font-medium text-gray-900">{correction.issue}</p>
+                                <p className="text-gray-600 mt-1">{correction.suggestion}</p>
+                              </div>
+                              {correction.priority && (
+                                <span className={`text-xs px-2 py-1 rounded ${
+                                  correction.priority === "high" ? "bg-red-100 text-red-700" :
+                                  correction.priority === "medium" ? "bg-yellow-100 text-yellow-700" :
+                                  "bg-gray-100 text-gray-700"
+                                }`}>
+                                  {correction.priority}
+                                </span>
+                              )}
+                            </div>
                           </div>
                         ))}
                       </div>
                     </div>
                   )}
+
+                  {result.corrections.corrected_prompt && (
+                    <div>
+                      <h4 className="font-semibold text-gray-900 mb-2">Corrected Prompt</h4>
+                      <div className="bg-gray-50 border border-gray-200 rounded-lg p-3 text-sm">
+                        <p className="text-gray-700">{result.corrections.corrected_prompt}</p>
+                      </div>
+                    </div>
+                  )}
+
+                  {/* Show message if no corrections were made */}
+                  {(!result.corrections.spelling_corrections || result.corrections.spelling_corrections.length === 0) &&
+                   (!result.corrections.visual_corrections || result.corrections.visual_corrections.length === 0) && (
+                    <div className="bg-gray-50 border border-gray-200 rounded-lg p-3 text-sm text-gray-600">
+                      <p>No specific corrections were identified. The image was regenerated based on your instructions.</p>
+                    </div>
+                  )}
                 </div>
               )}
             </div>
@@ -339,7 +377,13 @@ export const CorrectionModal: React.FC<CorrectionModalProps> = ({
               </Button>
             )}
             <Button
-              onClick={onClose}
+              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"}

frontend/components/generation/EditCopyModal.tsx

@@ -0,0 +1,334 @@
+"use client";
+
+import React, { useState, useEffect } from "react";
+import { X, Wand2, Edit3, Sparkles, Loader2, CheckCircle2, AlertCircle } from "lucide-react";
+import { editAdCopy } from "@/lib/api/endpoints";
+import type { AdCreativeDB } from "@/types/api";
+import { Button } from "@/components/ui/Button";
+import { Input } from "@/components/ui/Input";
+import { Card, CardContent } from "@/components/ui/Card";
+
+interface EditCopyModalProps {
+  isOpen: boolean;
+  onClose: () => void;
+  adId: string;
+  ad?: AdCreativeDB | null;
+  field: "title" | "headline" | "primary_text" | "description" | "body_story" | "cta";
+  fieldLabel: string;
+  currentValue: string;
+  onSuccess?: () => void;
+}
+
+type EditMode = "manual" | "ai";
+
+export const EditCopyModal: React.FC<EditCopyModalProps> = ({
+  isOpen,
+  onClose,
+  adId,
+  ad,
+  field,
+  fieldLabel,
+  currentValue,
+  onSuccess,
+}) => {
+  const [mode, setMode] = useState<EditMode>("manual");
+  const [editedValue, setEditedValue] = useState(currentValue);
+  const [aiSuggestion, setAiSuggestion] = useState("");
+  const [userSuggestion, setUserSuggestion] = useState("");
+  const [isLoading, setIsLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [success, setSuccess] = useState(false);
+
+  useEffect(() => {
+    if (isOpen) {
+      setEditedValue(currentValue);
+      setAiSuggestion("");
+      setUserSuggestion("");
+      setError(null);
+      setSuccess(false);
+      setMode("manual");
+    }
+  }, [isOpen, currentValue]);
+
+  const handleManualSave = async () => {
+    if (!editedValue.trim()) {
+      setError("This field cannot be empty");
+      return;
+    }
+
+    setIsLoading(true);
+    setError(null);
+
+    try {
+      await editAdCopy({
+        ad_id: adId,
+        field,
+        value: editedValue,
+        mode: "manual",
+      });
+
+      setSuccess(true);
+      setTimeout(() => {
+        onSuccess?.();
+        onClose();
+      }, 1000);
+    } catch (err: any) {
+      setError(err.message || "Failed to update. Please try again.");
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  const handleAIGenerate = async () => {
+    setIsLoading(true);
+    setError(null);
+
+    try {
+      const result = await editAdCopy({
+        ad_id: adId,
+        field,
+        value: currentValue,
+        mode: "ai",
+        user_suggestion: userSuggestion || undefined,
+      });
+
+      setAiSuggestion(result.edited_value || "");
+    } catch (err: any) {
+      setError(err.message || "Failed to generate AI suggestion. Please try again.");
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  const handleAIApply = async () => {
+    if (!aiSuggestion.trim()) {
+      setError("No AI suggestion available");
+      return;
+    }
+
+    setIsLoading(true);
+    setError(null);
+
+    try {
+      await editAdCopy({
+        ad_id: adId,
+        field,
+        value: aiSuggestion,
+        mode: "manual",
+      });
+
+      setSuccess(true);
+      setTimeout(() => {
+        onSuccess?.();
+        onClose();
+      }, 1000);
+    } catch (err: any) {
+      setError(err.message || "Failed to apply AI suggestion. Please try again.");
+    } finally {
+      setIsLoading(false);
+    }
+  };
+
+  if (!isOpen) return null;
+
+  return (
+    <div className="fixed inset-0 z-50 flex items-center justify-center bg-black/50 backdrop-blur-sm animate-fade-in">
+      <Card className="w-full max-w-2xl max-h-[90vh] overflow-y-auto shadow-2xl border-2 border-blue-200 animate-scale-in">
+        <CardContent className="p-6">
+          {/* Header */}
+          <div className="flex items-center justify-between mb-6">
+            <div className="flex items-center gap-3">
+              <div className="p-2 bg-gradient-to-r from-blue-500 to-cyan-500 rounded-lg">
+                <Edit3 className="h-5 w-5 text-white" />
+              </div>
+              <div>
+                <h2 className="text-xl font-bold bg-gradient-to-r from-blue-600 to-cyan-600 bg-clip-text text-transparent">
+                  Edit {fieldLabel}
+                </h2>
+                <p className="text-sm text-gray-500">Update your ad copy</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>
+
+          {/* Mode Toggle */}
+          <div className="flex gap-2 mb-6 p-1 bg-gray-100 rounded-lg">
+            <button
+              onClick={() => setMode("manual")}
+              className={`flex-1 flex items-center justify-center gap-2 px-4 py-2 rounded-md font-medium transition-all ${
+                mode === "manual"
+                  ? "bg-white text-blue-600 shadow-sm"
+                  : "text-gray-600 hover:text-gray-900"
+              }`}
+            >
+              <Edit3 className="h-4 w-4" />
+              Manual Edit
+            </button>
+            <button
+              onClick={() => setMode("ai")}
+              className={`flex-1 flex items-center justify-center gap-2 px-4 py-2 rounded-md font-medium transition-all ${
+                mode === "ai"
+                  ? "bg-white text-blue-600 shadow-sm"
+                  : "text-gray-600 hover:text-gray-900"
+              }`}
+            >
+              <Wand2 className="h-4 w-4" />
+              AI Edit
+            </button>
+          </div>
+
+          {/* Manual Edit Mode */}
+          {mode === "manual" && (
+            <div className="space-y-4">
+              <div>
+                <label className="block text-sm font-semibold text-gray-700 mb-2">
+                  {fieldLabel}
+                </label>
+                <textarea
+                  value={editedValue}
+                  onChange={(e) => setEditedValue(e.target.value)}
+                  className="w-full px-4 py-3 rounded-xl border-2 border-gray-300 bg-white focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500 transition-all resize-none"
+                  rows={field === "body_story" ? 8 : field === "description" ? 4 : 3}
+                  placeholder={`Enter your ${fieldLabel.toLowerCase()}...`}
+                />
+              </div>
+
+              {error && (
+                <div className="flex items-center gap-2 p-3 bg-red-50 border border-red-200 rounded-lg text-red-600">
+                  <AlertCircle className="h-4 w-4" />
+                  <span className="text-sm">{error}</span>
+                </div>
+              )}
+
+              {success && (
+                <div className="flex items-center gap-2 p-3 bg-green-50 border border-green-200 rounded-lg text-green-600">
+                  <CheckCircle2 className="h-4 w-4" />
+                  <span className="text-sm">Successfully updated!</span>
+                </div>
+              )}
+
+              <div className="flex gap-3">
+                <Button
+                  onClick={handleManualSave}
+                  isLoading={isLoading}
+                  variant="primary"
+                  className="flex-1"
+                >
+                  Save Changes
+                </Button>
+                <Button
+                  onClick={onClose}
+                  variant="ghost"
+                  disabled={isLoading}
+                >
+                  Cancel
+                </Button>
+              </div>
+            </div>
+          )}
+
+          {/* AI Edit Mode */}
+          {mode === "ai" && (
+            <div className="space-y-4">
+              <div>
+                <label className="block text-sm font-semibold text-gray-700 mb-2">
+                  Your Suggestion (Optional)
+                </label>
+                <textarea
+                  value={userSuggestion}
+                  onChange={(e) => setUserSuggestion(e.target.value)}
+                  className="w-full px-4 py-3 rounded-xl border-2 border-gray-300 bg-white focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500 transition-all resize-none"
+                  rows={3}
+                  placeholder="e.g., Make it more emotional, Add urgency, Make it shorter, Focus on benefits..."
+                />
+                <p className="text-xs text-gray-500 mt-1">
+                  Tell AI how you'd like the {fieldLabel.toLowerCase()} improved
+                </p>
+              </div>
+
+              <div>
+                <label className="block text-sm font-semibold text-gray-700 mb-2">
+                  Current {fieldLabel}
+                </label>
+                <div className="px-4 py-3 rounded-xl border-2 border-gray-200 bg-gray-50 text-gray-700">
+                  {currentValue || <span className="text-gray-400">No content</span>}
+                </div>
+              </div>
+
+              <Button
+                onClick={handleAIGenerate}
+                isLoading={isLoading}
+                variant="primary"
+                className="w-full"
+                disabled={isLoading}
+              >
+                <Wand2 className="h-4 w-4 mr-2" />
+                {isLoading ? "Generating..." : "Generate AI Suggestion"}
+              </Button>
+
+              {aiSuggestion && (
+                <div className="space-y-3">
+                  <div>
+                    <label className="block text-sm font-semibold text-gray-700 mb-2">
+                      AI Suggestion
+                    </label>
+                    <div className="px-4 py-3 rounded-xl border-2 border-blue-200 bg-blue-50 text-gray-700 whitespace-pre-line">
+                      {aiSuggestion}
+                    </div>
+                  </div>
+
+                  {error && (
+                    <div className="flex items-center gap-2 p-3 bg-red-50 border border-red-200 rounded-lg text-red-600">
+                      <AlertCircle className="h-4 w-4" />
+                      <span className="text-sm">{error}</span>
+                    </div>
+                  )}
+
+                  {success && (
+                    <div className="flex items-center gap-2 p-3 bg-green-50 border border-green-200 rounded-lg text-green-600">
+                      <CheckCircle2 className="h-4 w-4" />
+                      <span className="text-sm">Successfully updated!</span>
+                    </div>
+                  )}
+
+                  <div className="flex gap-3">
+                    <Button
+                      onClick={handleAIApply}
+                      isLoading={isLoading}
+                      variant="primary"
+                      className="flex-1"
+                    >
+                      Apply AI Suggestion
+                    </Button>
+                    <Button
+                      onClick={() => {
+                        setAiSuggestion("");
+                        setUserSuggestion("");
+                      }}
+                      variant="ghost"
+                      disabled={isLoading}
+                    >
+                      Regenerate
+                    </Button>
+                    <Button
+                      onClick={onClose}
+                      variant="ghost"
+                      disabled={isLoading}
+                    >
+                      Cancel
+                    </Button>
+                  </div>
+                </div>
+              )}
+            </div>
+          )}
+        </CardContent>
+      </Card>
+    </div>
+  );
+};

frontend/components/generation/ExtensiveForm.tsx

@@ -11,8 +11,8 @@ import type { Niche } from "@/types/api";
 
 const extensiveSchema = z.object({
   niche: z.enum(["home_insurance", "glp1"]),
-  target_audience: z.string().min(1, "Target audience is required"),
-  offer: z.string().min(1, "Offer is required"),
+  target_audience: z.string().optional(),
+  offer: z.string().optional(),
   num_images: z.number().min(1).max(3),
   num_strategies: z.number().min(1).max(10),
   image_model: z.string().nullable().optional(),
@@ -23,8 +23,8 @@ type ExtensiveFormData = z.infer<typeof extensiveSchema>;
 interface ExtensiveFormProps {
   onSubmit: (data: {
     niche: Niche;
-    target_audience: string;
-    offer: string;
+    target_audience?: string;
+    offer?: string;
     num_images: number;
     num_strategies: number;
     image_model?: string | null;
@@ -78,7 +78,7 @@ export const ExtensiveForm: React.FC<ExtensiveFormProps> = ({
 
           <div>
             <label className="block text-sm font-semibold text-gray-700 mb-2">
-              Target Audience <span className="text-red-500">*</span>
+              Target Audience
             </label>
             <input
               type="text"
@@ -93,7 +93,7 @@ export const ExtensiveForm: React.FC<ExtensiveFormProps> = ({
 
           <div>
             <label className="block text-sm font-semibold text-gray-700 mb-2">
-              Offer <span className="text-red-500">*</span>
+              Offer
             </label>
             <input
               type="text"

frontend/components/generation/GenerationForm.tsx

@@ -12,7 +12,7 @@ import { IMAGE_MODELS } from "@/lib/constants/models";
 import type { Niche } from "@/types/api";
 
 interface GenerationFormProps {
-  onSubmit: (data: { niche: Niche; num_images: number; image_model?: string | null }) => Promise<void>;
+  onSubmit: (data: { niche: Niche; num_images: number; image_model?: string | null; target_audience?: string; offer?: string }) => Promise<void>;
   isLoading: boolean;
 }
 
@@ -31,6 +31,8 @@ export const GenerationForm: React.FC<GenerationFormProps> = ({
       niche: "home_insurance" as Niche,
       num_images: 1,
       image_model: null,
+      target_audience: "",
+      offer: "",
     },
   });
 
@@ -56,6 +58,36 @@ export const GenerationForm: React.FC<GenerationFormProps> = ({
             {...register("niche")}
           />
 
+          <div>
+            <label className="block text-sm font-semibold text-gray-700 mb-2">
+              Target Audience
+            </label>
+            <input
+              type="text"
+              className="w-full px-4 py-3 rounded-xl border-2 border-gray-300 bg-white/80 backdrop-blur-sm focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500 transition-all duration-250"
+              placeholder="e.g., US people over 50+ age"
+              {...register("target_audience")}
+            />
+            {errors.target_audience && (
+              <p className="text-red-500 text-xs mt-1">{errors.target_audience.message}</p>
+            )}
+          </div>
+
+          <div>
+            <label className="block text-sm font-semibold text-gray-700 mb-2">
+              Offer
+            </label>
+            <input
+              type="text"
+              className="w-full px-4 py-3 rounded-xl border-2 border-gray-300 bg-white/80 backdrop-blur-sm focus:outline-none focus:ring-2 focus:ring-blue-500 focus:border-blue-500 transition-all duration-250"
+              placeholder="e.g., Don't overpay your insurance"
+              {...register("offer")}
+            />
+            {errors.offer && (
+              <p className="text-red-500 text-xs mt-1">{errors.offer.message}</p>
+            )}
+          </div>
+
           <Select
             label="Image Model"
             options={IMAGE_MODELS.map(model => ({ value: model.value, label: model.label }))}
@@ -65,7 +97,7 @@ export const GenerationForm: React.FC<GenerationFormProps> = ({
 
           <div>
             <label className="block text-sm font-semibold text-gray-700 mb-2">
-              Number of Variations: <span className="text-blue-600 font-bold">{numImages}</span>
+              Number of Images: <span className="text-blue-600 font-bold">{numImages}</span>
             </label>
             <input
               type="range"
@@ -80,7 +112,7 @@ export const GenerationForm: React.FC<GenerationFormProps> = ({
               <span>10</span>
             </div>
             <p className="text-xs text-gray-500 mt-1">
-              Each variation will have a unique image and slight copy variations
+              Generate multiple images for the same ad copy using the same method
             </p>
             {errors.num_images && (
               <p className="mt-1 text-sm text-red-600">

frontend/components/generation/GenerationProgress.tsx

@@ -75,7 +75,8 @@ export const GenerationProgressComponent: React.FC<GenerationProgressProps> = ({
     error: 0,
   };
 
-  const currentProgress = progress.progress || stepProgress[progress.step];
+  // Use nullish coalescing (??) instead of || to properly handle 0 as a valid progress value
+  const currentProgress = progress.progress ?? stepProgress[progress.step];
   const currentStepIndex = STEPS.findIndex(s => s.key === progress.step);
   const isComplete = progress.step === "complete";
   const isError = progress.step === "error";

frontend/lib/api/endpoints.ts

@@ -35,6 +35,8 @@ export const generateAd = async (params: {
   niche: Niche;
   num_images: number;
   image_model?: string | null;
+  target_audience?: string;
+  offer?: string;
 }): Promise<GenerateResponse> => {
   const response = await apiClient.post<GenerateResponse>("/generate", params);
   return response.data;
@@ -45,6 +47,9 @@ export const generateBatch = async (params: {
   count: number;
   images_per_ad: number;
   image_model?: string | null;
+  method?: "standard" | "matrix" | null;
+  target_audience?: string;
+  offer?: string;
 }): Promise<BatchResponse> => {
   const response = await apiClient.post<BatchResponse>("/generate/batch", params);
   return response.data;
@@ -57,6 +62,8 @@ export const generateMatrixAd = async (params: {
   concept_key?: string | null;
   num_images: number;
   image_model?: string | null;
+  target_audience?: string;
+  offer?: string;
 }): Promise<MatrixGenerateResponse> => {
   const response = await apiClient.post<MatrixGenerateResponse>("/matrix/generate", params);
   return response.data;
@@ -65,8 +72,8 @@ export const generateMatrixAd = async (params: {
 // Extensive Endpoint
 export const generateExtensiveAd = async (params: {
   niche: Niche;
-  target_audience: string;
-  offer: string;
+  target_audience?: string;
+  offer?: string;
   num_images: number;
   image_model?: string | null;
   num_strategies: number;
@@ -74,10 +81,10 @@ export const generateExtensiveAd = async (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.target_audience && { target_audience: params.target_audience }),
+    ...(params.offer && { offer: params.offer }),
     ...(params.image_model && { image_model: params.image_model }),
   };
   const response = await apiClient.post<GenerateResponse>("/extensive/generate", requestParams);
@@ -169,3 +176,27 @@ export const login = async (username: string, password: string): Promise<LoginRe
   });
   return response.data;
 };
+
+// Edit Ad Copy Endpoint
+export const editAdCopy = async (params: {
+  ad_id: string;
+  field: "title" | "headline" | "primary_text" | "description" | "body_story" | "cta";
+  value: string;
+  mode: "manual" | "ai";
+  user_suggestion?: string;
+}): Promise<{ edited_value: string; success: boolean }> => {
+  const response = await apiClient.post<{ edited_value: string; success: boolean }>("/db/ad/edit", params);
+  return response.data;
+};
+
+// Download Image Endpoint (proxy to avoid CORS)
+export const downloadImageProxy = async (params: {
+  image_url?: string;
+  image_id?: string;
+}): Promise<Blob> => {
+  const response = await apiClient.get("/api/download-image", {
+    params,
+    responseType: "blob",
+  });
+  return response.data as Blob;
+};

frontend/lib/utils/export.ts

@@ -1,13 +1,18 @@
 // Export utilities for downloading/exporting ads
+import { downloadImageProxy } from "@/lib/api/endpoints";
 
-export const downloadImage = async (url: string | null | undefined, filename: string | null | undefined): Promise<void> => {
-  if (!url) {
-    throw new Error("No image URL provided");
+export const downloadImage = async (url: string | null | undefined, filename: string | null | undefined, adId?: string): Promise<void> => {
+  if (!url && !adId) {
+    throw new Error("No image URL or ad ID provided");
   }
   
   try {
-    const response = await fetch(url);
-    const blob = await response.blob();
+    // Use proxy endpoint to avoid CORS issues
+    const blob = await downloadImageProxy({
+      image_url: url || undefined,
+      image_id: adId || undefined,
+    });
+    
     const blobUrl = window.URL.createObjectURL(blob);
     const link = document.createElement("a");
     link.href = blobUrl;

frontend/lib/utils/validators.ts

@@ -4,6 +4,8 @@ export const generateAdSchema = z.object({
   niche: z.enum(["home_insurance", "glp1"]),
   num_images: z.number().min(1).max(10),
   image_model: z.string().optional().nullable(),
+  target_audience: z.string().optional(),
+  offer: z.string().optional(),
 });
 
 export const generateBatchSchema = z.object({
@@ -11,6 +13,8 @@ export const generateBatchSchema = z.object({
   count: z.number().min(1).max(20),
   images_per_ad: z.number().min(1).max(3),
   image_model: z.string().optional().nullable(),
+  target_audience: z.string().optional(),
+  offer: z.string().optional(),
 });
 
 export const generateMatrixSchema = z.object({
@@ -19,6 +23,8 @@ export const generateMatrixSchema = z.object({
   concept_key: z.string().optional().nullable(),
   num_images: z.number().min(1).max(5),
   image_model: z.string().optional().nullable(),
+  target_audience: z.string().optional(),
+  offer: z.string().optional(),
 });
 
 export const testingMatrixSchema = z.object({

frontend/store/galleryStore.ts

@@ -48,6 +48,7 @@ export const useGalleryStore = create<GalleryState>((set, get) => ({
   setFilters: (filters) => set((state) => ({
     filters: { ...state.filters, ...filters },
     offset: 0, // Reset to first page when filters change
+    selectedAds: [], // Clear selections when filters change
   })),
   
   setSortOptions: (sort) => set({ sortOptions: sort, offset: 0 }), // Reset to first page when sort changes

frontend/types/api.ts

@@ -27,7 +27,7 @@ export interface GenerateResponse {
   id: string;
   niche: string;
   created_at: string;
-  title: string;
+  title?: string | null;
   headline: string;
   primary_text: string;
   description: string;
@@ -72,7 +72,7 @@ export interface MatrixGenerateResponse {
   id: string;
   niche: string;
   created_at: string;
-  title: string;
+  title?: string | null;
   headline: string;
   primary_text: string;
   description: string;
@@ -183,6 +183,18 @@ export interface AdCreativeDB {
   concept_name?: string | null;
   generation_method?: string | null;
   created_at?: string | null;
+  metadata?: {
+    original_image_url?: string | null;
+    original_r2_url?: string | null;
+    original_image_filename?: string | null;
+    original_image_model?: string | null;
+    original_image_prompt?: string | null;
+    is_corrected?: boolean;
+    correction_date?: string | null;
+    corrections?: CorrectionData | null;
+    [key: string]: any;
+  } | null;
+  r2_url?: string | null;
 }
 
 export interface AdsListResponse {

main.py

@@ -11,6 +11,7 @@ from fastapi.staticfiles import StaticFiles
 from fastapi.responses import FileResponse, StreamingResponse, Response as FastAPIResponse
 from pydantic import BaseModel, Field
 from typing import Optional, List, Literal, Any, Dict
+from datetime import datetime
 import os
 import logging
 import time
@@ -117,6 +118,14 @@ class GenerateRequest(BaseModel):
         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')"
     )
+    target_audience: Optional[str] = Field(
+        default=None,
+        description="Optional target audience description (e.g., 'US people over 50+ age')"
+    )
+    offer: Optional[str] = Field(
+        default=None,
+        description="Optional offer to run (e.g., 'Don't overpay your insurance')"
+    )
 
 
 class GenerateBatchRequest(BaseModel):
@@ -140,6 +149,18 @@ class GenerateBatchRequest(BaseModel):
         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')"
     )
+    method: Optional[Literal["standard", "matrix"]] = Field(
+        default=None,
+        description="Generation method: 'standard' for standard method only, 'matrix' for matrix method only, None for mixed (50/50)"
+    )
+    target_audience: Optional[str] = Field(
+        default=None,
+        description="Optional target audience description (e.g., 'US people over 50+ age')"
+    )
+    offer: Optional[str] = Field(
+        default=None,
+        description="Optional offer to run (e.g., 'Don't overpay your insurance')"
+    )
 
 
 class ImageResult(BaseModel):
@@ -170,11 +191,11 @@ class GenerateResponse(BaseModel):
     id: str
     niche: str
     created_at: str
-    title: str = Field(description="Short punchy ad title (3-5 words)")
+    title: Optional[str] = Field(default=None, description="Short punchy ad title (3-5 words) - only for extensive flow")
     headline: str
     primary_text: str
     description: str
-    body_story: str = Field(description="Compelling 4-6 sentence story that hooks emotionally")
+    body_story: str = Field(description="Compelling 8-12 sentence story that hooks emotionally")
     cta: str
     psychological_angle: str
     why_it_works: Optional[str] = None
@@ -212,6 +233,14 @@ class MatrixGenerateRequest(BaseModel):
         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')"
     )
+    target_audience: Optional[str] = Field(
+        default=None,
+        description="Optional target audience description (e.g., 'US people over 50+ age')"
+    )
+    offer: Optional[str] = Field(
+        default=None,
+        description="Optional offer to run (e.g., 'Don't overpay your insurance')"
+    )
 
 
 class MatrixBatchRequest(BaseModel):
@@ -270,11 +299,11 @@ class MatrixGenerateResponse(BaseModel):
     id: str
     niche: str
     created_at: str
-    title: str = Field(description="Short punchy ad title (3-5 words)")
+    title: Optional[str] = Field(default=None, description="Short punchy ad title (3-5 words) - not used in matrix flow")
     headline: str
     primary_text: str
     description: str
-    body_story: str = Field(description="Compelling 4-6 sentence story that hooks emotionally")
+    body_story: str = Field(description="Compelling 8-12 sentence story that hooks emotionally")
     cta: str
     psychological_angle: str
     why_it_works: Optional[str] = None
@@ -482,6 +511,7 @@ async def generate_batch(
             images_per_ad=request.images_per_ad,
             image_model=request.image_model,
             username=username,  # Pass current user
+            method=request.method,  # Pass method parameter
         )
         return {
             "count": len(results),
@@ -500,6 +530,82 @@ async def get_image(filename: str):
     return FileResponse(filepath)
 
 
+@app.get("/api/download-image")
+async def download_image_proxy(
+    image_url: Optional[str] = None,
+    image_id: Optional[str] = None,
+    username: str = Depends(get_current_user)
+):
+    """
+    Proxy endpoint to download images, avoiding CORS issues.
+    Can fetch from external URLs (R2, Replicate) or local files.
+    """
+    import httpx
+    
+    filename = None
+    
+    # If image_id is provided, verify ownership
+    if image_id:
+        ad = await db_service.get_ad_creative(image_id)
+        if not ad:
+            raise HTTPException(status_code=404, detail="Ad not found")
+        
+        # Verify ownership
+        if ad.get("username") != username:
+            raise HTTPException(status_code=403, detail="Access denied")
+        
+        # Only use ad's image URL if image_url was not explicitly provided
+        # This allows downloading original images from metadata
+        if not image_url:
+            image_url = ad.get("r2_url") or ad.get("image_url")
+            filename = ad.get("image_filename")
+        else:
+            # If image_url is provided, try to get filename from metadata if it's an original image
+            metadata = ad.get("metadata", {})
+            if metadata.get("original_r2_url") == image_url or metadata.get("original_image_url") == image_url:
+                filename = metadata.get("original_image_filename")
+    
+    if not image_url:
+        raise HTTPException(status_code=400, detail="No image URL provided")
+    
+    try:
+        # Check if it's a local file
+        if not image_url.startswith(("http://", "https://")):
+            # Local file
+            filepath = os.path.join(settings.output_dir, image_url)
+            if os.path.exists(filepath):
+                return FileResponse(filepath, filename=filename or os.path.basename(filepath))
+            raise HTTPException(status_code=404, detail="Image file not found")
+        
+        # External URL - fetch and proxy
+        async with httpx.AsyncClient(timeout=30.0) as client:
+            response = await client.get(image_url)
+            response.raise_for_status()
+            
+            # Determine content type
+            content_type = response.headers.get("content-type", "image/png")
+            
+            # Get filename from URL or use provided filename
+            if not filename:
+                # Try to extract from URL
+                filename = image_url.split("/")[-1].split("?")[0]
+                if not filename or "." not in filename:
+                    filename = "image.png"
+            
+            return FastAPIResponse(
+                content=response.content,
+                media_type=content_type,
+                headers={
+                    "Content-Disposition": f'attachment; filename="{filename}"',
+                    "Cache-Control": "public, max-age=3600",
+                }
+            )
+    except httpx.HTTPError as e:
+        raise HTTPException(status_code=502, detail=f"Failed to fetch image: {str(e)}")
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error downloading image: {str(e)}")
+
+
 # =============================================================================
 # IMAGE CORRECTION ENDPOINTS
 # =============================================================================
@@ -676,55 +782,76 @@ async def correct_image(
                 "corrected_prompt": corrected_img.get("corrected_prompt"),
             }
         
-        # Save corrected image to database as a new ad creative
+        # Update original ad with corrected image (instead of creating new one)
         if result.get("status") == "success" and result.get("_db_metadata"):
             db_metadata = result["_db_metadata"]
             try:
-                api_logger.info("Saving corrected image to database as new ad creative...")
-                # Save as a new ad creative with same copy but corrected image
-                corrected_ad_id = await db_service.save_ad_creative(
-                    niche=ad.get("niche", ""),
-                    title=ad.get("title", ""),
-                    headline=ad.get("headline", ""),
-                    primary_text=ad.get("primary_text", ""),
-                    description=ad.get("description", ""),
-                    body_story=ad.get("body_story", ""),
-                    cta=ad.get("cta", ""),
-                    psychological_angle=ad.get("psychological_angle", ""),
-                    why_it_works=ad.get("why_it_works", ""),
-                    username=username,  # Pass current user
-                    image_url=db_metadata.get("image_url"),
-                    image_filename=db_metadata.get("filename"),
-                    image_model=db_metadata.get("model_used"),
-                    image_prompt=db_metadata.get("corrected_prompt"),
-                    angle_key=ad.get("angle_key"),
-                    angle_name=ad.get("angle_name"),
-                    angle_trigger=ad.get("angle_trigger"),
-                    angle_category=ad.get("angle_category"),
-                    concept_key=ad.get("concept_key"),
-                    concept_name=ad.get("concept_name"),
-                    concept_structure=ad.get("concept_structure"),
-                    concept_visual=ad.get("concept_visual"),
-                    concept_category=ad.get("concept_category"),
-                    generation_method="correction",
-                    metadata={
-                        "original_ad_id": request.image_id,
-                        "corrections": result.get("corrections"),
-                        "is_corrected": True,
-                    },
+                api_logger.info("Updating original ad with corrected image...")
+                
+                # 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_image_prompt = ad.get("image_prompt")
+                
+                # Prepare metadata with old image info and corrections
+                # Only include fields that have values
+                correction_metadata = {
+                    "is_corrected": True,
+                    "correction_date": datetime.utcnow().isoformat() + "Z",
+                }
+                
+                # Add original image data only if it exists
+                if old_image_url:
+                    correction_metadata["original_image_url"] = old_image_url
+                if old_r2_url:
+                    correction_metadata["original_r2_url"] = old_r2_url
+                if old_image_filename:
+                    correction_metadata["original_image_filename"] = old_image_filename
+                if old_image_model:
+                    correction_metadata["original_image_model"] = old_image_model
+                if old_image_prompt:
+                    correction_metadata["original_image_prompt"] = old_image_prompt
+                if result.get("corrections"):
+                    correction_metadata["corrections"] = result.get("corrections")
+                
+                api_logger.info(f"Prepared correction metadata: {correction_metadata}")
+                api_logger.info(f"Old image URL: {old_image_url}")
+                api_logger.info(f"Old R2 URL: {old_r2_url}")
+                
+                # Update the original ad with corrected image
+                # Also update r2_url if available
+                update_kwargs = {
+                    "image_url": db_metadata.get("image_url"),
+                    "image_filename": db_metadata.get("filename"),
+                    "image_model": db_metadata.get("model_used"),
+                    "image_prompt": db_metadata.get("corrected_prompt"),
+                }
+                if db_metadata.get("r2_url"):
+                    update_kwargs["r2_url"] = db_metadata.get("r2_url")
+                
+                api_logger.info(f"Updating ad {request.image_id} with metadata: {correction_metadata}")
+                update_success = await db_service.update_ad_creative(
+                    ad_id=request.image_id,
+                    username=username,
+                    metadata=correction_metadata,
+                    **update_kwargs
                 )
-                if corrected_ad_id:
-                    api_logger.info(f"✓ Corrected image saved to database with ID: {corrected_ad_id}")
-                    # Add the new ad ID to the response
+                api_logger.info(f"Update success: {update_success}")
+                
+                if update_success:
+                    api_logger.info(f"✓ Original ad updated with corrected image (ID: {request.image_id})")
+                    # Add the updated ad ID to the response
                     if "corrected_image" not in response_data:
                         response_data["corrected_image"] = {}
-                    response_data["corrected_image"]["ad_id"] = corrected_ad_id
+                    response_data["corrected_image"]["ad_id"] = request.image_id
                 else:
-                    api_logger.warning("Failed to save corrected image to database (no ID returned)")
+                    api_logger.warning("Failed to update ad with corrected image (update returned False)")
             except Exception as e:
-                api_logger.error(f"Failed to save corrected image to database: {e}")
-                api_logger.exception("Database save error details:")
-                # Don't fail the request if database save fails
+                api_logger.error(f"Failed to update ad with corrected image: {e}")
+                api_logger.exception("Database update error details:")
+                # Don't fail the request if database update fails
         
         total_api_time = time.time() - api_start_time
         api_logger.info("=" * 80)
@@ -980,11 +1107,13 @@ class ExtensiveGenerateRequest(BaseModel):
     niche: Literal["home_insurance", "glp1"] = Field(
         description="Target niche"
     )
-    target_audience: str = Field(
-        description="Target audience description (e.g., 'US people over 50+ age')"
+    target_audience: Optional[str] = Field(
+        default=None,
+        description="Optional target audience description (e.g., 'US people over 50+ age')"
     )
-    offer: str = Field(
-        description="Offer to run (e.g., 'Don't overpay your insurance')"
+    offer: Optional[str] = Field(
+        default=None,
+        description="Optional offer to run (e.g., 'Don't overpay your insurance')"
     )
     num_images: int = Field(
         default=1,
@@ -1169,6 +1298,7 @@ async def get_stored_ad(ad_id: str):
         "image_filename": ad.get("image_filename"),
         "image_model": ad.get("image_model"),
         "image_seed": ad.get("image_seed"),
+        "r2_url": ad.get("r2_url"),  # Include r2_url in response
         "angle_key": ad.get("angle_key"),
         "angle_name": ad.get("angle_name"),
         "angle_trigger": ad.get("angle_trigger"),
@@ -1200,6 +1330,120 @@ async def delete_stored_ad(ad_id: str, username: str = Depends(get_current_user)
     return {"success": True, "deleted_id": ad_id}
 
 
+class EditAdCopyRequest(BaseModel):
+    """Request for editing ad copy."""
+    ad_id: str = Field(description="ID of the ad to edit")
+    field: Literal["title", "headline", "primary_text", "description", "body_story", "cta"] = Field(
+        description="Field to edit"
+    )
+    value: str = Field(description="New value for the field (for manual edit) or current value (for AI edit)")
+    mode: Literal["manual", "ai"] = Field(description="Edit mode: manual or AI")
+    user_suggestion: Optional[str] = Field(
+        default=None,
+        description="User suggestion for AI editing (optional)"
+    )
+
+
+@app.post("/db/ad/edit")
+async def edit_ad_copy(
+    request: EditAdCopyRequest,
+    username: str = Depends(get_current_user)
+):
+    """
+    Edit ad copy fields with manual or AI assistance.
+    
+    Requires authentication. Users can only edit their own ads.
+    
+    Modes:
+    - manual: Directly update the field with the provided value
+    - ai: Generate an improved version using AI, optionally with user suggestions
+    """
+    from services.llm import LLMService
+    
+    # Verify ad exists and belongs to user
+    ad = await db_service.get_ad_creative(request.ad_id)
+    if not ad:
+        raise HTTPException(status_code=404, detail=f"Ad '{request.ad_id}' not found")
+    
+    if ad.get("username") != username:
+        raise HTTPException(status_code=403, detail="You can only edit your own ads")
+    
+    if request.mode == "manual":
+        # Direct update
+        update_data = {request.field: request.value}
+        success = await db_service.update_ad_creative(
+            ad_id=request.ad_id,
+            username=username,
+            **update_data
+        )
+        
+        if not success:
+            raise HTTPException(status_code=500, detail="Failed to update ad")
+        
+        return {
+            "edited_value": request.value,
+            "success": True
+        }
+    
+    else:  # AI mode
+        # Generate improved version using AI
+        llm_service = LLMService()
+        
+        # Build context for AI
+        field_labels = {
+            "title": "title",
+            "headline": "headline",
+            "primary_text": "primary text",
+            "description": "description",
+            "body_story": "body story",
+            "cta": "call to action"
+        }
+        
+        field_label = field_labels.get(request.field, request.field)
+        current_value = request.value
+        niche = ad.get("niche", "general")
+        
+        # Build prompt
+        system_prompt = f"""You are an expert copywriter specializing in high-converting ad copy for {niche.replace('_', ' ')}.
+Your task is to improve the {field_label} while maintaining its core message and emotional impact.
+Keep the same tone and style, but make it more compelling, clear, and effective."""
+
+        user_prompt = f"""Current {field_label}:
+{current_value}
+
+"""
+        
+        if request.user_suggestion:
+            user_prompt += f"""User's suggestion: {request.user_suggestion}
+
+"""
+        
+        user_prompt += f"""Please provide an improved version of this {field_label} that:
+1. Maintains the core message and emotional impact
+2. Is more compelling and engaging
+3. Follows best practices for {field_label} in ad copy
+4. {"Incorporates the user's suggestion" if request.user_suggestion else "Is optimized for conversion"}
+
+Return ONLY the improved {field_label} text, without any explanations or additional text."""
+
+        try:
+            edited_value = await llm_service.generate(
+                prompt=user_prompt,
+                system_prompt=system_prompt,
+                temperature=0.7
+            )
+            
+            # Clean up the response (remove quotes if wrapped)
+            edited_value = edited_value.strip().strip('"').strip("'")
+            
+            return {
+                "edited_value": edited_value,
+                "success": True
+            }
+        except Exception as e:
+            raise HTTPException(status_code=500, detail=f"Failed to generate AI edit: {str(e)}")
+
+
 # Frontend proxy - forward non-API requests to Next.js
 # This must be LAST so it doesn't intercept API routes
 @app.api_route("/{path:path}", methods=["GET", "POST", "PUT", "DELETE", "PATCH", "OPTIONS"])
@@ -1211,7 +1455,7 @@ async def frontend_proxy(path: str, request: StarletteRequest):
     # Exact API-only routes (never frontend)
     # Note: /health has its own explicit route, so not listed here
     api_only_routes = [
-        "auth/login", "api/correct", "db/stats", "db/ads",
+        "auth/login", "api/correct", "api/download-image", "db/stats", "db/ads",
         "strategies", "extensive/generate"
     ]
     
@@ -1227,6 +1471,11 @@ async def frontend_proxy(path: str, request: StarletteRequest):
         "matrix/compatible", "db/ad"
     ]
     
+    # Routes that are API for POST
+    api_post_routes_additional = [
+        "db/ad/edit"
+    ]
+    
     # Check if this is an API-only route
     if any(path == route or path.startswith(f"{route}/") for route in api_only_routes):
         raise HTTPException(status_code=404, detail="API endpoint not found")
@@ -1235,6 +1484,10 @@ async def frontend_proxy(path: str, request: StarletteRequest):
     if request.method == "POST" and any(path == route or path.startswith(f"{route}/") for route in api_post_routes):
         raise HTTPException(status_code=404, detail="API endpoint not found")
     
+    # Check additional POST routes
+    if request.method == "POST" and any(path == route or path.startswith(f"{route}/") for route in api_post_routes_additional):
+        raise HTTPException(status_code=404, detail="API endpoint not found")
+    
     # Check if path starts with image serving routes
     if path.startswith("image/") or path.startswith("images/"):
         raise HTTPException(status_code=404, detail="API endpoint not found")

services/database.py

@@ -237,6 +237,89 @@ class DatabaseService:
             print(f"Failed to list ad creatives: {e}")
             return [], 0
     
+    async def update_ad_creative(
+        self,
+        ad_id: str,
+        username: Optional[str] = None,
+        image_url: Optional[str] = None,
+        image_filename: Optional[str] = None,
+        image_model: Optional[str] = None,
+        image_prompt: Optional[str] = None,
+        metadata: Optional[Dict[str, Any]] = None,
+        **kwargs
+    ) -> bool:
+        """
+        Update an ad creative by ID.
+        If username is provided, only updates if the ad belongs to that user.
+        
+        Args:
+            ad_id: ID of the ad to update
+            username: Optional username to verify ownership
+            image_url: New image URL
+            image_filename: New image filename
+            image_model: New image model
+            image_prompt: New image prompt
+            metadata: Metadata dict (will be merged with existing metadata)
+            **kwargs: Additional fields to update
+        
+        Returns:
+            True if update was successful, False otherwise
+        """
+        if self.collection is None:
+            return False
+        
+        try:
+            # Try to convert to ObjectId if it's a valid ObjectId string
+            try:
+                object_id = ObjectId(ad_id)
+            except:
+                # If not a valid ObjectId, try as string
+                object_id = ad_id
+            
+            query = {"_id": object_id}
+            if username:
+                query["username"] = username
+            
+            # Build update document
+            update_doc = {"updated_at": datetime.utcnow()}
+            
+            if image_url is not None:
+                update_doc["image_url"] = image_url
+            if image_filename is not None:
+                update_doc["image_filename"] = image_filename
+            if image_model is not None:
+                update_doc["image_model"] = image_model
+            if image_prompt is not None:
+                update_doc["image_prompt"] = image_prompt
+            
+            # Add any additional fields from kwargs
+            for key, value in kwargs.items():
+                if value is not None:
+                    update_doc[key] = value
+            
+            # Handle metadata merge
+            if metadata is not None:
+                # Get existing ad to merge metadata
+                existing_ad = await self.collection.find_one(query)
+                if existing_ad:
+                    existing_metadata = existing_ad.get("metadata") or {}
+                    # Merge metadata (new values override old ones)
+                    merged_metadata = {**existing_metadata, **metadata}
+                    update_doc["metadata"] = merged_metadata
+                    print(f"Debug: Merging metadata. Existing: {existing_metadata}, New: {metadata}, Merged: {merged_metadata}")
+                else:
+                    update_doc["metadata"] = metadata
+                    print(f"Debug: Setting new metadata (no existing ad found): {metadata}")
+            
+            result = await self.collection.update_one(
+                query,
+                {"$set": update_doc}
+            )
+            return result.modified_count > 0
+        except Exception as e:
+            print(f"Failed to update ad creative: {e}")
+            return False
+    
     async def delete_ad_creative(self, ad_id: str, username: Optional[str] = None) -> bool:
         """
         Delete an ad creative by ID.

services/generator.py

@@ -71,72 +71,6 @@ NICHE_DATA = {
 # Note: Frameworks are now loaded from data/frameworks.py
 # This provides comprehensive framework data with hooks, visual styles, and niche-specific recommendations
 
-# =============================================================================
-# WINNING AD FORMATS (from high-converting creative analysis)
-# =============================================================================
-
-# Format types that bypass ad-blindness
-WINNING_AD_FORMATS = [
-    {
-        "name": "accusation_opener",
-        "description": "Direct accusation that triggers loss aversion immediately",
-        "headline_pattern": "[ACCUSATION]?",
-        "examples": ["OVERPAYING?", "Still Underinsured?", "Wasting Money?"],
-        "visual_style": "person with money/bills, documentary candid shot",
-    },
-    {
-        "name": "curiosity_gap",
-        "description": "Open loop that demands click to close",
-        "headline_pattern": "[Group] are [action] and doing THIS instead",
-        "examples": [
-            "Seniors Are Ditching Their Home Insurance & Doing This Instead",
-            "Thousands of homeowners are dropping their home insurance after THIS",
-        ],
-        "visual_style": "candid documentary photo, real person, everyday setting",
-    },
-    {
-        "name": "specific_price_anchor",
-        "description": "Oddly specific price creates believability",
-        "headline_pattern": "[Product] for as low as $XX.XX/month",
-        "examples": ["Home Insurance for as low as $97.33/month", "$43/month"],
-        "visual_style": "clean typography focus, price dominant, age selector buttons",
-    },
-    {
-        "name": "before_after_proof",
-        "description": "Social proof with specific numbers",
-        "headline_pattern": "WAS: $X,XXX → NOW: $XXX",
-        "examples": ["WAS: $1,701 → NOW: $583"],
-        "visual_style": "real person holding document with circled numbers",
-    },
-    {
-        "name": "quiz_interactive",
-        "description": "Interactive quiz format that drives engagement",
-        "headline_pattern": "[Personal Question]?",
-        "examples": ["What Year Was Your House Built?", "Tap your age to calculate"],
-        "visual_style": "notes app screenshot, dark mode UI, checkbox options",
-    },
-    {
-        "name": "authority_transfer",
-        "description": "Transfer trust from government/institution",
-        "headline_pattern": "[Authority] + [Benefit] for [Group]",
-        "examples": ["State Farm Brings Welfare!", "Sponsored by the US government"],
-        "visual_style": "government seal, official document aesthetic, institutional",
-    },
-    {
-        "name": "identity_targeting",
-        "description": "Direct demographic callout for self-selection",
-        "headline_pattern": "[Demographic] Won't Have To Pay More Than $XX",
-        "examples": ["Seniors Won't Have To Pay More Than $49 A Month"],
-        "visual_style": "real seniors, portrait photography, relatable faces",
-    },
-    {
-        "name": "insider_secret",
-        "description": "Exclusivity and hidden knowledge framing",
-        "headline_pattern": "The [Adjective] Way To [Benefit]",
-        "examples": ["The Easiest Way To Cut Home Insurance Bills"],
-        "visual_style": "person revealing information, document proof, testimonial style",
-    },
-]
 
 # Age brackets for identity targeting (proven high-CTR pattern)
 AGE_BRACKETS = [
@@ -384,8 +318,32 @@ class AdGenerator:
                 "seasonal": home_insurance.SEASONAL_VISUALS,
             }
         elif niche == "glp1":
-            # Add GLP-1 visual library if available
-            return {}
+            from data import glp1
+            return {
+                "diet_fatigue": glp1.DIET_FATIGUE_VISUALS,
+                "clothes_body_awareness": glp1.CLOTHES_BODY_AWARENESS_VISUALS,
+                "health_wake_up_calls": glp1.HEALTH_WAKE_UP_CALLS_VISUALS,
+                "mental_load_food_noise": glp1.MENTAL_LOAD_FOOD_NOISE_VISUALS,
+                "survival_life_extension": glp1.SURVIVAL_LIFE_EXTENSION_VISUALS,
+                "freedom_from_fear_pain": glp1.FREEDOM_FROM_FEAR_PAIN_VISUALS,
+                "sexual_companionship": glp1.SEXUAL_COMPANIONSHIP_VISUALS,
+                "comfortable_living": glp1.COMFORTABLE_LIVING_VISUALS,
+                "superiority_winning": glp1.SUPERIORITY_WINNING_VISUALS,
+                "care_protection_loved_ones": glp1.CARE_PROTECTION_LOVED_ONES_VISUALS,
+                "social_approval": glp1.SOCIAL_APPROVAL_VISUALS,
+                "why_moment": glp1.WHY_MOMENT_VISUALS,
+                "when_moment": glp1.WHEN_MOMENT_VISUALS,
+                "where_moment": glp1.WHERE_MOMENT_VISUALS,
+                "with_whom": glp1.WITH_WHOM_VISUALS,
+                "with_what_activity": glp1.WITH_WHAT_ACTIVITY_VISUALS,
+                "while_wearing_using": glp1.WHILE_WEARING_USING_VISUALS,
+                "while_feeling": glp1.WHILE_FEELING_VISUALS,
+                "unaware": glp1.UNAWARE_VISUALS,
+                "problem_aware": glp1.PROBLEM_AWARE_VISUALS,
+                "solution_aware": glp1.SOLUTION_AWARE_VISUALS,
+                "product_aware": glp1.PRODUCT_AWARE_VISUALS,
+                "most_aware": glp1.MOST_AWARE_VISUALS,
+            }
         return {}
     
     def _select_visuals_from_library(self, niche: str, strategy_name: str, count: int = 2) -> List[str]:
@@ -546,10 +504,6 @@ NICHE-SPECIFIC REQUIREMENTS (GLP-1 / WEIGHT LOSS):
             }
         return {}
     
-    def _select_ad_format(self) -> Dict[str, Any]:
-        """Randomly select a winning ad format."""
-        return random.choice(WINNING_AD_FORMATS)
-    
     def _get_framework_container_compatibility(self, framework_key: str) -> List[str]:
         """
         Get container types that are most compatible with a framework.
@@ -637,20 +591,21 @@ NICHE-SPECIFIC REQUIREMENTS (GLP-1 / WEIGHT LOSS):
         trigger_data: Dict[str, Any] = None,
         trigger_combination: Dict[str, Any] = None,
         power_words: List[str] = None,
+        angle: Dict[str, Any] = None,
+        concept: Dict[str, Any] = None,
     ) -> str:
         """
         Build professional LLM prompt for ad copy generation.
-        Uses winning ad patterns from high-converting creatives analysis.
+        Uses angle × concept matrix approach for psychological targeting.
         """
         strategy_names = [s["name"] for s in strategies]
         strategy_descriptions = [f"- {s['name']}: {s['description']}" for s in strategies]
         cta = random.choice(niche_data["ctas"])
         niche_guidance = self._get_niche_specific_guidance(niche)
         
-        # Select winning format and container (native-looking format)
+        # Select container (native-looking format)
         # Use framework-aware container selection (improvement)
         container_strategy = "framework_aware" if random.random() < 0.6 else random.choice(["native", "ugc", "alert", "balanced"])
-        ad_format = self._select_ad_format()
         container = self._select_container(prefer_native=True, strategy=container_strategy, framework_key=framework_data.get("key"))
         price_guidance = self._generate_specific_price(niche)
         niche_numbers = self._generate_niche_numbers(niche)
@@ -668,7 +623,7 @@ You may include specific numbers if they enhance the ad's believability and fit
 - Target Age Bracket: {age_bracket['label']}
 
 DECISION: You decide whether to include these numbers based on:
-- The ad format (some formats work better with numbers, others without)
+- The psychological angle (some angles work better with numbers, others without)
 - The psychological strategy (some strategies benefit from specificity, others from emotional appeal)
 - The overall message flow
 
@@ -684,7 +639,7 @@ You may include specific prices/numbers if they enhance the ad's believability a
 - Target Age Bracket: {age_bracket['label']}
 
 DECISION: You decide whether to include prices/numbers based on:
-- The ad format (e.g., "specific_price_anchor" format benefits from prices, "curiosity_gap" may not)
+- The psychological angle (some angles benefit from prices, others may not)
 - The psychological strategy (some strategies need specificity, others work better emotionally)
 - The overall message flow and what feels most authentic
 
@@ -774,12 +729,16 @@ FRAMEWORK HOOK EXAMPLES: {', '.join(framework_hooks[:3]) if framework_hooks else
 CREATIVE DIRECTION: {creative_direction}
 CALL-TO-ACTION: {cta}
 
-=== WINNING AD FORMAT TO USE ===
-FORMAT: {ad_format['name']}
-DESCRIPTION: {ad_format['description']}
-PATTERN: {ad_format['headline_pattern']}
-EXAMPLES: {', '.join(ad_format['examples'])}
-VISUAL STYLE: {ad_format['visual_style']}
+=== ANGLE × CONCEPT FRAMEWORK ===
+ANGLE: {angle.get('name') if angle else 'N/A'}
+- Psychological Trigger: {angle.get('trigger') if angle else 'N/A'}
+- Example Hook: "{angle.get('example') if angle else 'N/A'}"
+- This angle answers WHY they should care
+
+CONCEPT: {concept.get('name') if concept else 'N/A'}
+- Visual Structure: {concept.get('structure') if concept else 'N/A'}
+- Visual Guidance: {concept.get('visual') if concept else 'N/A'}
+- This concept defines HOW to show it visually
 
 === CONTAINER FORMAT (Native-Looking Ad) ===
 CONTAINER TYPE: {container['name']}
@@ -813,21 +772,22 @@ FRAMEWORK HOOK EXAMPLES: {', '.join(framework_hooks[:5]) if framework_hooks else
 
 {headline_formulas}
 === YOUR MISSION ===
-Create a SCROLL-STOPPING Facebook ad for {niche.replace("_", " ").upper()} using the format "{ad_format['name']}" that looks like organic content, not advertising.
+Create a SCROLL-STOPPING Facebook ad for {niche.replace("_", " ").upper()} using the "{angle.get('name') if angle else 'psychological'}" angle and "{concept.get('name') if concept else 'visual'}" concept that looks like organic content, not advertising.
 
 === OUTPUT REQUIREMENTS ===
 
 1. HEADLINE (The "Arrest")
-   - Follow the {ad_format['name']} pattern
+   - Use the "{angle.get('name') if angle else 'psychological'}" angle to trigger {angle.get('trigger') if angle else 'emotion'}
    - MAXIMUM 10 words
    - Must create INSTANT pattern interrupt
-   - You decide whether to include specific numbers/prices based on the ad format and what will be most effective. If including prices, make them oddly specific (e.g., "$97.33" not "$100") for believability.
+   - You decide whether to include specific numbers/prices based on the angle and what will be most effective. If including prices, make them oddly specific (e.g., "$97.33" not "$100") for believability.
    - Include demographic targeting where appropriate
    - NO generic phrases - be SPECIFIC and EMOTIONAL
    
 2. PRIMARY TEXT (The "Agitation")
    - 2-3 punchy sentences that AMPLIFY the emotional hook
-   - You decide whether to include specific numbers/prices based on the ad format and strategy. If including, make them oddly specific for believability.
+   - Use the "{angle.get('name') if angle else 'psychological'}" angle to deepen emotional connection
+   - You decide whether to include specific numbers/prices based on the angle and strategy. If including, make them oddly specific for believability.
    - Reference the demographic appropriately
    - Create urgency
    - Make them FEEL the pain or desire
@@ -838,14 +798,15 @@ Create a SCROLL-STOPPING Facebook ad for {niche.replace("_", " ").upper()} using
    - Create action urgency
 
 4. IMAGE BRIEF (CRITICAL - must match {container['name']} container style)
+   - Follow the "{concept.get('name') if concept else 'visual'}" concept: {concept.get('structure') if concept else 'authentic visual'}
    - Describe the scene for the {container['name']} container format ONLY
    - Visual guidance: {get_container_visual_guidance(container.get('key', ''))}
    - The image should look like ORGANIC CONTENT, not an ad
    - Include: setting, subjects, props, mood
    - Follow container authenticity tips: {', '.join(container.get('authenticity_tips', [])[:2])}
    - CRITICAL: Use ONLY {container['name']} format - DO NOT mix with other container types (no WhatsApp + memo, no iMessage + document)
-   - {"If chat container: Include 2-4 readable, coherent messages related to home insurance. Use the headline or a variation as one message." if container.get('key') in ['imessage', 'whatsapp', 'sms', 'reddit_post', 'social_post'] else ""}
-   - {"If document container: Include readable, properly formatted text related to home insurance." if container.get('key') in ['memo', 'email_notification', 'browser_alert'] else ""}
+   - {f"If chat container: Include 2-4 readable, coherent messages related to {niche.replace('_', ' ').title()}. Use the headline or a variation as one message." if container.get('key') in ['imessage', 'whatsapp', 'sms', 'reddit_post', 'social_post'] else ""}
+   - {f"If document container: Include readable, properly formatted text related to {niche.replace('_', ' ').title()}." if container.get('key') in ['memo', 'email_notification', 'browser_alert'] else ""}
    - FOR GLP-1: Use VARIETY - show different visual types: quiz interfaces, doctor/medical settings, person on scale, mirror reflections, lifestyle moments, confidence scenes, testimonial portraits, celebrity references, or before/after (only when strategy calls for it) use diverse visual concepts.
    - FOR HOME INSURANCE: Show person with document, savings proof, home setting
 
@@ -867,17 +828,15 @@ Create a SCROLL-STOPPING Facebook ad for {niche.replace("_", " ").upper()} using
 
 === OUTPUT FORMAT (JSON) ===
 {{
-    "title": "Short, punchy ad title (3-5 words max) - think of it as the campaign name",
-    "headline": "Your pattern-matching headline using {ad_format['name']} format",
+    "headline": "Your headline using the {angle.get('name') if angle else 'psychological'} angle to trigger {angle.get('trigger') if angle else 'emotion'}",
     "primary_text": "Your 2-3 sentence emotional amplification with specific numbers",
     "description": "Your one powerful sentence",
-    "body_story": "A compelling 4-6 sentence STORY that hooks the reader emotionally. Start with a relatable situation or pain point. Build tension. Show the transformation. End with hope and a soft CTA. Write in first or second person for intimacy.",
-    "image_brief": "Detailed description matching {container['name']} container style - organic content feel",
+    "body_story": "A compelling 8-12 sentence STORY that hooks the reader emotionally. Start with a relatable situation or pain point. Build tension gradually. Show the transformation with vivid details. End with hope and a soft CTA. Write in first or second person for intimacy. Make it engaging and detailed enough to fully capture the reader's attention.",
+    "image_brief": "Detailed description following '{concept.get('name') if concept else 'visual'}' concept and matching {container['name']} container style - organic content feel",
     "cta": "{cta}",
-    "ad_format_used": "{ad_format['name']}",
     "container_used": "{container['name']}",
     "container_key": "{container.get('key', '')}",
-    "psychological_angle": "Primary psychological trigger being used",
+    "psychological_angle": "{angle.get('name') if angle else 'Primary psychological trigger being used'}",
     "why_it_works": "Brief explanation of the psychological mechanism"
 }}
 
@@ -908,7 +867,6 @@ Generate the ad copy now for {niche.replace("_", " ").upper()}. Make it look lik
         psychological_angle = ad_copy.get("psychological_angle", "")
         container_key = ad_copy.get("container_key", "")
         container_name = ad_copy.get("container_used", "Standard Ad")
-        ad_format = ad_copy.get("ad_format_used", "curiosity_gap")
         price_anchor = ad_copy.get("price_anchor", "$97")
         
         # Get container data if key is available
@@ -1019,7 +977,7 @@ REQUIREMENTS:
 {"=== TEXT REQUIREMENTS FOR CHAT CONTAINERS ===" if is_chat_container else ""}
 {"CRITICAL: All text in chat bubbles MUST be:" if is_chat_container else ""}
 {"- READABLE and COHERENT (not gibberish, not placeholder text)" if is_chat_container else ""}
-{"- Realistic conversation text related to home insurance" if is_chat_container else ""}
+{f"- Realistic conversation text related to {niche.replace('_', ' ').title()}" if is_chat_container else ""}
 {"- Proper spelling and grammar" if is_chat_container else ""}
 {"- Natural message flow (2-4 messages max)" if is_chat_container else ""}
 {"- Use the headline or a variation as one of the messages" if is_chat_container else ""}
@@ -1028,7 +986,7 @@ REQUIREMENTS:
 {"=== TEXT REQUIREMENTS FOR DOCUMENT CONTAINERS ===" if is_document_container else ""}
 {"CRITICAL: All text in documents MUST be:" if is_document_container else ""}
 {"- READABLE and COHERENT" if is_document_container else ""}
-{"- Related to home insurance topic" if is_document_container else ""}
+{f"- Related to {niche.replace('_', ' ').title()} topic" if is_document_container else ""}
 {"- Proper formatting (title, body text, etc.)" if is_document_container else ""}
 {"- NO gibberish or placeholder text" if is_document_container else ""}
 """
@@ -1053,7 +1011,7 @@ REQUIREMENTS:
 
 CRITICAL REMINDERS:
 - Use ONLY {container.get('name', 'Standard Ad')} format - NO mixing with other containers
-- If using chat container: All text MUST be readable, coherent, and related to home insurance
+- If using chat container: All text MUST be readable, coherent, and related to the {niche.replace('_', ' ').title()} niche
 - If using document container: All text MUST be readable and properly formatted
 - NO gibberish, placeholder text, or random characters
 - NO decorative borders, frames, or boxes
@@ -1431,6 +1389,11 @@ CRITICAL REQUIREMENTS:
         # Get niche visual guidance
         niche_visual_guidance_data = get_niche_visual_guidance(niche)
         
+        # Get random angle × concept combination (like matrix generation)
+        combination = matrix_service.generate_single_combination(niche)
+        angle = combination["angle"]
+        concept = combination["concept"]
+        
         # Generate ad copy via LLM with professional prompt
         copy_prompt = self._build_copy_prompt(
             niche=niche,
@@ -1444,6 +1407,8 @@ CRITICAL REQUIREMENTS:
             trigger_data=trigger_data,
             trigger_combination=trigger_combination,
             power_words=power_words,
+            angle=angle,
+            concept=concept,
         )
         
         ad_copy = await llm_service.generate_json(
@@ -1569,7 +1534,7 @@ CRITICAL REQUIREMENTS:
             try:
                 db_id = await db_service.save_ad_creative(
                     niche=niche,
-                    title=ad_copy.get("title", ""),
+                    title=None,  # No title for standard flow
                     headline=ad_copy.get("headline", ""),
                     primary_text=ad_copy.get("primary_text", ""),
                     description=ad_copy.get("description", ""),
@@ -1584,6 +1549,15 @@ CRITICAL REQUIREMENTS:
                     image_seed=first_image.get("seed"),
                     image_prompt=first_image.get("image_prompt"),  # Save the final refined prompt
                     generation_method="standard",
+                    angle_key=angle.get("key"),
+                    angle_name=angle.get("name"),
+                    angle_trigger=angle.get("trigger"),
+                    angle_category=angle.get("category"),
+                    concept_key=concept.get("key"),
+                    concept_name=concept.get("name"),
+                    concept_structure=concept.get("structure"),
+                    concept_visual=concept.get("visual"),
+                    concept_category=concept.get("category"),
                     metadata=metadata,
                 )
                 if db_id:
@@ -1599,7 +1573,6 @@ CRITICAL REQUIREMENTS:
             "created_at": datetime.now().isoformat(),
             
             # Ad copy
-            "title": ad_copy.get("title", ""),
             "headline": ad_copy.get("headline", ""),
             "primary_text": ad_copy.get("primary_text", ""),
             "description": ad_copy.get("description", ""),
@@ -1690,7 +1663,6 @@ CONCEPT: {concept['name']}
                 "schema": {
                     "type": "object",
                     "properties": {
-                        "title": {"type": "string"},
                         "headline": {"type": "string"},
                         "primary_text": {"type": "string"},
                         "description": {"type": "string"},
@@ -1700,7 +1672,7 @@ CONCEPT: {concept['name']}
                         "psychological_angle": {"type": "string"},
                         "why_it_works": {"type": "string"},
                     },
-                    "required": ["title", "headline", "primary_text", "description", "body_story", "image_brief", "cta"],
+                    "required": ["headline", "primary_text", "description", "body_story", "image_brief", "cta"],
                 },
             },
         }
@@ -1817,7 +1789,7 @@ CONCEPT: {concept['name']}
             try:
                 db_id = await db_service.save_ad_creative(
                     niche=niche,
-                    title=ad_copy.get("title", ""),
+                    title=None,  # No title for matrix flow
                     headline=ad_copy.get("headline", ""),
                     primary_text=ad_copy.get("primary_text", ""),
                     description=ad_copy.get("description", ""),
@@ -1853,7 +1825,6 @@ CONCEPT: {concept['name']}
             "id": ad_id,
             "niche": niche,
             "created_at": datetime.now().isoformat(),
-            "title": ad_copy.get("title", ""),
             "headline": ad_copy.get("headline", ""),
             "primary_text": ad_copy.get("primary_text", ""),
             "description": ad_copy.get("description", ""),
@@ -1885,8 +1856,8 @@ CONCEPT: {concept['name']}
     async def generate_ad_extensive(
         self,
         niche: str,
-        target_audience: str,
-        offer: str,
+        target_audience: Optional[str] = None,
+        offer: Optional[str] = None,
         num_images: int = 1,
         image_model: Optional[str] = None,
         num_strategies: int = 5,
@@ -1897,8 +1868,8 @@ CONCEPT: {concept['name']}
         
         Args:
             niche: Target niche (home_insurance or glp1)
-            target_audience: Target audience description
-            offer: Offer to run
+            target_audience: Optional target audience description
+            offer: Optional offer to run
             num_images: Number of images to generate per strategy
             image_model: Image generation model to use
             num_strategies: Number of creative strategies to generate
@@ -1916,6 +1887,12 @@ CONCEPT: {concept['name']}
         }
         niche_display = niche_map.get(niche, niche.title())
         
+        # Provide defaults if target_audience or offer are not provided
+        if not target_audience:
+            target_audience = f"People interested in {niche_display}"
+        if not offer:
+            offer = f"Get the best {niche_display} solution"
+        
         # Step 1: Researcher
         print("🔍 Step 1: Researching psychology triggers, angles, and concepts...")
         researcher_output = third_flow_service.researcher(
@@ -2244,11 +2221,10 @@ Create a scroll-stopping ad that:
 
 === OUTPUT (JSON) ===
 {{
-    "title": "Short punchy title (3-5 words) - the campaign/ad name",
     "headline": "10 words max, triggers {angle.get('trigger')}. You decide whether to include specific numbers based on what enhances the message.",
     "primary_text": "2-3 emotional sentences. You decide whether to include specific numbers based on what enhances believability and fits the strategy.",
     "description": "One powerful sentence, 10 words max",
-    "body_story": "A compelling 4-6 sentence STORY. Start with relatable pain/situation. Build tension. Show transformation. End with hope. Write in first/second person.",
+    "body_story": "A compelling 8-12 sentence STORY. Start with relatable pain/situation. Build tension gradually with vivid details. Show transformation with specific examples. End with hope and emotional connection. Write in first/second person. Make it engaging and detailed enough to fully capture the reader's attention.",
     "image_brief": "Detailed scene description following '{concept.get('name')}' concept: {concept.get('structure')}",
     "cta": "{cta}",
     "psychological_angle": "{angle.get('name')}",
@@ -2360,16 +2336,19 @@ Create a scroll-stopping ad image with "{headline}" prominently displayed."""
         images_per_ad: int = 1,
         image_model: Optional[str] = None,
         username: Optional[str] = None,  # Username of the user generating the ads
+        method: Optional[str] = None,  # "standard", "matrix", or None (mixed)
     ) -> List[Dict[str, Any]]:
         """
         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
             count: Number of ads to generate
-            images_per_ad: Images per ad
+            images_per_ad: Images per ad (typically 1 for batch)
+            image_model: Image model to use
+            username: Username of the user generating the ads
+            method: Generation method - "standard", "matrix", or None (mixed 50/50)
             
         Returns:
             List of ad results (all normalized to GenerateResponse format)
@@ -2381,8 +2360,14 @@ Create a scroll-stopping ad image with "{headline}" prominently displayed."""
             """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
+                    # Use method parameter to determine generation type
+                    if method == "matrix":
+                        use_matrix = True
+                    elif method == "standard":
+                        use_matrix = False
+                    else:
+                        # Default: 50% standard, 50% matrix (ensures all resources used)
+                        use_matrix = random.random() < 0.5
                     
                     if use_matrix:
                         # Use angle × concept matrix approach