Implement motivator generation feature for ad creation

- Added a new MotivatorGenerateRequest model and corresponding API endpoint to generate emotional motivators based on user-selected niche, angle, and concept.
- Integrated motivator generation into the ad creation workflow, allowing users to select motivators for enhanced ad targeting.
- Updated the frontend to support motivator generation, including state management for selecting and displaying generated motivators.
- Enhanced the generator service to incorporate motivators into ad copy and image prompts, ensuring a cohesive user experience.
- Refactored API types and endpoints to accommodate the new motivator generation functionality, maintaining type safety and consistency across the application.

frontend/app/generate/page.tsx

@@ -12,11 +12,11 @@ import { ConceptSelector } from "@/components/matrix/ConceptSelector";
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/Card";
 import { Button } from "@/components/ui/Button";
 import { ProgressBar } from "@/components/ui/ProgressBar";
-import { generateAd, generateMatrixAd, generateBatch, generateExtensiveAd, refineCustomAngleOrConcept } from "@/lib/api/endpoints";
+import { generateAd, generateMatrixAd, generateBatch, generateExtensiveAd, refineCustomAngleOrConcept, generateMotivators } from "@/lib/api/endpoints";
 import { useGenerationStore } from "@/store/generationStore";
 import { useMatrixStore } from "@/store/matrixStore";
 import { toast } from "react-hot-toast";
-import { Sparkles, Zap, Layers, Package, Workflow, Wand2, Check, Loader2 } from "lucide-react";
+import { Sparkles, Zap, Layers, Package, Workflow, Wand2, Check, Loader2, Brain } from "lucide-react";
 import { IMAGE_MODELS } from "@/lib/constants/models";
 import type { Niche, GenerateResponse, AngleInfo, ConceptInfo } from "@/types/api";
 
@@ -35,6 +35,17 @@ export default function GeneratePage() {
   const [batchCount, setBatchCount] = useState(0);
   const [batchImagesPerAd, setBatchImagesPerAd] = useState(1);
 
+  // Motivators (Matrix mode): generate from angle+concept, user selects one or more for ad generation
+  const [motivators, setMotivators] = useState<string[]>([]);
+  const [selectedMotivators, setSelectedMotivators] = useState<string[]>([]);
+  const [isGeneratingMotivators, setIsGeneratingMotivators] = useState(false);
+
+  const toggleMotivator = (m: string) => {
+    setSelectedMotivators((prev) =>
+      prev.includes(m) ? prev.filter((x) => x !== m) : [...prev, m]
+    );
+  };
+
   const {
     currentGeneration,
     progress,
@@ -163,6 +174,40 @@ export default function GeneratePage() {
   const effectiveAngle = useCustomAngle ? customAngleRefined : selectedAngle;
   const effectiveConcept = useCustomConcept ? customConceptRefined : selectedConcept;
 
+  const handleGenerateMotivators = async () => {
+    if (!effectiveAngle || !effectiveConcept) {
+      toast.error("Select an angle and a concept first");
+      return;
+    }
+    setIsGeneratingMotivators(true);
+    setMotivators([]);
+    setSelectedMotivators([]);
+    try {
+      const res = await generateMotivators({
+        niche,
+        angle: {
+          name: effectiveAngle.name,
+          trigger: effectiveAngle.trigger,
+          example: (effectiveAngle as AngleInfo).example ?? effectiveAngle.name,
+        },
+        concept: {
+          name: effectiveConcept.name,
+          structure: effectiveConcept.structure,
+          visual: effectiveConcept.visual,
+        },
+        target_audience: targetAudience || undefined,
+        offer: offer || undefined,
+        count: 6,
+      });
+      setMotivators(res.motivators);
+      toast.success(`Generated ${res.motivators.length} motivators`);
+    } catch (e: unknown) {
+      toast.error(e instanceof Error ? e.message : "Failed to generate motivators");
+    } finally {
+      setIsGeneratingMotivators(false);
+    }
+  };
+
   const handleStandardGenerate = async (data: { niche: Niche; num_images: number; image_model?: string | null; target_audience?: string; offer?: string }) => {
     reset();
     setIsGenerating(true);
@@ -306,19 +351,24 @@ export default function GeneratePage() {
       try {
         // Generate batch using matrix method
         const results = await Promise.all(
-          Array.from({ length: numImages }, (_, i) =>
-            generateMatrixAd({
+          Array.from({ length: numImages }, (_, i) => {
+            const motivator =
+              selectedMotivators.length > 0
+                ? selectedMotivators[i % selectedMotivators.length]
+                : undefined;
+            return generateMatrixAd({
               niche,
               angle_key: useCustomAngle ? "custom" : effectiveAngle.key,
               concept_key: useCustomConcept ? "custom" : effectiveConcept.key,
               custom_angle: useCustomAngle ? JSON.stringify(effectiveAngle) : null,
               custom_concept: useCustomConcept ? JSON.stringify(effectiveConcept) : null,
-              num_images: 1, // Each ad gets 1 image
+              num_images: 1,
               image_model: imageModel,
               target_audience: targetAudience || undefined,
               offer: offer || undefined,
-            })
-          )
+              core_motivator: motivator,
+            });
+          })
         );
 
         setBatchResults(results as unknown as GenerateResponse[]);
@@ -358,16 +408,19 @@ export default function GeneratePage() {
       });
 
       try {
+        const motivator =
+          selectedMotivators.length > 0 ? selectedMotivators[0] : undefined;
         const result = await generateMatrixAd({
           niche,
           angle_key: useCustomAngle ? "custom" : effectiveAngle.key,
           concept_key: useCustomConcept ? "custom" : effectiveConcept.key,
           custom_angle: useCustomAngle ? JSON.stringify(effectiveAngle) : null,
           custom_concept: useCustomConcept ? JSON.stringify(effectiveConcept) : null,
-          num_images: 1, // Single image
+          num_images: 1,
           image_model: imageModel,
           target_audience: targetAudience || undefined,
           offer: offer || undefined,
+          core_motivator: motivator,
         });
 
         setCurrentGeneration(result);
@@ -1014,6 +1067,79 @@ export default function GeneratePage() {
                   </Card>
                 )}
 
+                {/* Motivators: generate from angle+concept, select one for ad generation */}
+                <Card variant="glass" className="border-2 border-purple-200 bg-gradient-to-br from-purple-50/50 to-pink-50/50">
+                  <CardHeader>
+                    <CardTitle className="flex items-center gap-2 text-base">
+                      <Brain className="h-5 w-5 text-purple-600" />
+                      Motivators
+                    </CardTitle>
+                  </CardHeader>
+                  <CardContent className="space-y-4">
+                    <p className="text-xs text-gray-600">
+                      Generate emotional motivators from your angle + concept. Pick one or more—each will be used for a separate image when generating multiple.
+                    </p>
+                    <Button
+                      variant="secondary"
+                      size="sm"
+                      className="w-full"
+                      onClick={handleGenerateMotivators}
+                      disabled={!effectiveAngle || !effectiveConcept || isGeneratingMotivators}
+                    >
+                      {isGeneratingMotivators ? (
+                        <>
+                          <Loader2 className="w-4 h-4 animate-spin mr-2" />
+                          Generating…
+                        </>
+                      ) : (
+                        <>
+                          <Brain className="w-4 h-4 mr-2" />
+                          Generate Motivators
+                        </>
+                      )}
+                    </Button>
+                    {motivators.length > 0 && (
+                      <div className="space-y-2">
+                        <p className="text-xs font-semibold text-gray-700">
+                          Pick one or more for ad generation:
+                        </p>
+                        <div className="space-y-1.5 max-h-48 overflow-y-auto">
+                          {motivators.map((m, i) => {
+                            const selected = selectedMotivators.includes(m);
+                            return (
+                              <button
+                                key={i}
+                                type="button"
+                                onClick={() => toggleMotivator(m)}
+                                className={`w-full text-left px-3 py-2 rounded-lg border-2 text-sm transition-all ${
+                                  selected
+                                    ? "border-purple-500 bg-purple-100 text-purple-900"
+                                    : "border-gray-200 bg-white hover:border-purple-300 hover:bg-purple-50"
+                                }`}
+                              >
+                                <span className="flex items-center gap-2">
+                                  {selected && (
+                                    <Check className="w-4 h-4 text-purple-600 flex-shrink-0" />
+                                  )}
+                                  &ldquo;{m}&rdquo;
+                                </span>
+                              </button>
+                            );
+                          })}
+                        </div>
+                        {selectedMotivators.length > 0 && (
+                          <p className="text-xs text-purple-700 font-medium">
+                            Using {selectedMotivators.length} motivator
+                            {selectedMotivators.length !== 1 ? "s" : ""} for generation
+                            {numImages > 1 &&
+                              ` (cycled across ${numImages} image${numImages !== 1 ? "s" : ""})`}
+                          </p>
+                        )}
+                      </div>
+                    )}
+                  </CardContent>
+                </Card>
+
                 {/* Selection Summary */}
                 <Card variant="glass" className="border-2 border-blue-100 bg-gradient-to-r from-blue-50/50 to-cyan-50/50">
                   <CardContent className="pt-4 pb-4">
@@ -1041,6 +1167,23 @@ export default function GeneratePage() {
                           <span className="text-gray-400 italic">Not selected</span>
                         )}
                       </div>
+                      {selectedMotivators.length > 0 && (
+                        <div className="pt-1 border-t border-blue-200 mt-2 space-y-1">
+                          <span className="font-medium text-gray-600 block">
+                            Motivator{selectedMotivators.length !== 1 ? "s" : ""}:
+                          </span>
+                          <ul className="list-disc list-inside space-y-0.5 max-h-24 overflow-y-auto">
+                            {selectedMotivators.map((m, i) => (
+                              <li
+                                key={i}
+                                className="text-purple-600 font-medium text-xs"
+                              >
+                                &ldquo;{m}&rdquo;
+                              </li>
+                            ))}
+                          </ul>
+                        </div>
+                      )}
                     </div>
                   </CardContent>
                 </Card>

frontend/lib/api/endpoints.ts

@@ -24,6 +24,8 @@ import type {
   FileUploadResponse,
   ModificationMode,
   CreativeAnalysisData,
+  MotivatorGenerateRequest,
+  MotivatorGenerateResponse,
 } from "../../types/api";
 
 // Health & Info
@@ -73,11 +75,22 @@ export const generateMatrixAd = async (params: {
   image_model?: string | null;
   target_audience?: string;
   offer?: string;
+  core_motivator?: string;
 }): Promise<MatrixGenerateResponse> => {
   const response = await apiClient.post<MatrixGenerateResponse>("/matrix/generate", params);
   return response.data;
 };
 
+export const generateMotivators = async (
+  params: MotivatorGenerateRequest
+): Promise<MotivatorGenerateResponse> => {
+  const response = await apiClient.post<MotivatorGenerateResponse>(
+    "/api/motivator/generate",
+    { ...params, count: params.count ?? 6 }
+  );
+  return response.data;
+};
+
 // Extensive Endpoint
 export const generateExtensiveAd = async (params: {
   niche: Niche;

frontend/types/api.ts

@@ -409,3 +409,16 @@ export interface ModelsListResponse {
   models: ImageModel[];
   default: string;
 }
+
+export interface MotivatorGenerateRequest {
+  niche: Niche;
+  angle: { name: string; trigger: string; example?: string; [k: string]: unknown };
+  concept: { name: string; structure: string; visual: string; [k: string]: unknown };
+  target_audience?: string;
+  offer?: string;
+  count?: number;
+}
+
+export interface MotivatorGenerateResponse {
+  motivators: string[];
+}

main.py

@@ -28,6 +28,7 @@ from services.correction import correction_service
 from services.image import image_service
 from services.auth import auth_service
 from services.auth_dependency import get_current_user
+from services.motivator import generate_motivators as motivator_generate
 from config import settings
 
 # Configure logging for API
@@ -251,6 +252,10 @@ class MatrixGenerateRequest(BaseModel):
         default=None,
         description="Optional offer to run (e.g., 'Don't overpay your insurance')"
     )
+    core_motivator: Optional[str] = Field(
+        default=None,
+        description="Optional motivator selected by user to guide ad generation"
+    )
 
 
 class RefineCustomRequest(BaseModel):
@@ -298,6 +303,26 @@ class RefineCustomResponse(BaseModel):
     error: Optional[str] = None
 
 
+# Motivator generation (angle + concept context)
+class MotivatorGenerateRequest(BaseModel):
+    """Request to generate motivators from niche + angle + concept."""
+    niche: Literal["home_insurance", "glp1"] = Field(description="Target niche")
+    angle: Dict[str, Any] = Field(
+        description="Angle context: name, trigger, example (and optional key, category)"
+    )
+    concept: Dict[str, Any] = Field(
+        description="Concept context: name, structure, visual (and optional key, category)"
+    )
+    target_audience: Optional[str] = Field(default=None, description="Optional target audience")
+    offer: Optional[str] = Field(default=None, description="Optional offer")
+    count: int = Field(default=6, ge=3, le=10, description="Number of motivators to generate")
+
+
+class MotivatorGenerateResponse(BaseModel):
+    """Response with generated motivators."""
+    motivators: List[str]
+
+
 class MatrixBatchRequest(BaseModel):
     """Request for batch matrix generation."""
     niche: Literal["home_insurance", "glp1"] = Field(
@@ -413,6 +438,7 @@ async def api_info():
             "GET /matrix/concept/{key}": "Get specific concept details",
             "GET /matrix/compatible/{angle_key}": "Get compatible concepts for angle",
             "POST /extensive/generate": "Generate ad using extensive (researcher → creative director → designer → copywriter)",
+            "POST /api/motivator/generate": "Generate motivators from niche + angle + concept (Matrix mode)",
             "POST /api/correct": "Correct image for spelling mistakes and visual issues (requires image_id)",
             "POST /api/regenerate": "Regenerate image with optional model selection (requires image_id)",
             "GET /api/models": "List all available image generation models",
@@ -1433,7 +1459,8 @@ async def generate_with_matrix(
             custom_concept=request.custom_concept,
             num_images=request.num_images,
             image_model=request.image_model,
-            username=username,  # Pass current user
+            username=username,
+            core_motivator=request.core_motivator,
         )
         return result
     except Exception as e:
@@ -1634,6 +1661,35 @@ async def refine_custom_angle_or_concept(request: RefineCustomRequest):
         }
 
 
+# =============================================================================
+# MOTIVATOR ENDPOINTS
+# =============================================================================
+
+@app.post("/api/motivator/generate", response_model=MotivatorGenerateResponse)
+async def motivator_generate_endpoint(
+    request: MotivatorGenerateRequest,
+    username: str = Depends(get_current_user),
+):
+    """
+    Generate multiple motivators from niche + angle + concept context.
+
+    Used in Matrix mode: user selects angle and concept, then generates motivators
+    to review and pick one for ad generation.
+    """
+    try:
+        motivators = await motivator_generate(
+            niche=request.niche,
+            angle=request.angle,
+            concept=request.concept,
+            target_audience=request.target_audience,
+            offer=request.offer,
+            count=request.count,
+        )
+        return MotivatorGenerateResponse(motivators=motivators)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
 # =============================================================================
 # EXTENSIVE ENDPOINTS
 # =============================================================================

services/generator.py

@@ -1691,7 +1691,8 @@ CRITICAL REQUIREMENTS:
         custom_concept: Optional[str] = None,
         num_images: int = 1,
         image_model: Optional[str] = None,
-        username: Optional[str] = None,  # Username of the user generating the ad
+        username: Optional[str] = None,
+        core_motivator: Optional[str] = None,
     ) -> Dict[str, Any]:
         """
         Generate ad using angle × concept matrix approach.
@@ -1800,6 +1801,7 @@ CONCEPT: {concept.get('name', 'Custom Concept')}
             angle=angle,
             concept=concept,
             niche_data=niche_data,
+            core_motivator=core_motivator,
         )
         
         # Generate ad copy
@@ -1839,6 +1841,7 @@ CONCEPT: {concept.get('name', 'Custom Concept')}
             angle=angle,
             concept=concept,
             ad_copy=ad_copy,
+            core_motivator=core_motivator,
         )
         
         # Store the refined prompt for database saving (this is the final prompt sent to image service)
@@ -2471,6 +2474,7 @@ Return JSON:
         angle: Dict[str, Any],
         concept: Dict[str, Any],
         niche_data: Dict[str, Any],
+        core_motivator: Optional[str] = None,
     ) -> str:
         """Build ad copy prompt using angle + concept framework."""
         
@@ -2499,8 +2503,16 @@ DECISION: Include prices/numbers only if they enhance believability and fit the
 Use oddly specific amounts (e.g., "$97.33" not "$100") when including prices."""
         # Note: AI decides whether to use the numbers based on format and strategy
         
-        return f"""You are an elite direct-response copywriter creating a Facebook ad.
+        motivator_block = ""
+        if core_motivator:
+            motivator_block = f"""
+=== CORE EMOTIONAL MOTIVATOR (USE THIS) ===
+The user chose this motivator: "{core_motivator}"
 
+Use it to guide the hook, headline, and primary text. The ad must amplify this motivator.
+"""
+        return f"""You are an elite direct-response copywriter creating a Facebook ad.
+{motivator_block}
 === ANGLE × CONCEPT FRAMEWORK ===
 
 ANGLE: {angle.get('name')}
@@ -2544,13 +2556,29 @@ Generate the ad now. Be bold, be specific, trigger {angle.get('trigger')}."""
         angle: Dict[str, Any],
         concept: Dict[str, Any],
         ad_copy: Dict[str, Any],
+        core_motivator: Optional[str] = None,
     ) -> str:
         """Build image prompt using concept's visual guidance."""
-        
         headline = ad_copy.get("headline", "")
+        # When user selected a motivator, show it on the image instead of headline (like title)
+        text_on_image = (core_motivator or "").strip() or (headline or "")
+        use_motivator = bool((core_motivator or "").strip())
         image_brief = ad_copy.get("image_brief", "")
         
-        # Text styling based on concept
+        # Natural blend options: motivator/text feels part of the scene, not forced
+        natural_blend_options = [
+            "as a handwritten note or sticky note in the scene",
+            "as text on a phone screen, tablet, or laptop in frame",
+            "as a message in a chat or social feed within the image",
+            "on a sign, whiteboard, or poster that fits the environment",
+            "as a caption or note lying naturally in the scene",
+            "reflected in a mirror or window as part of the environment",
+            "on a document, receipt, or paper in the scene",
+            "as subtle text on a product or package in frame",
+        ]
+        text_blend = random.choice(natural_blend_options)
+        
+        # Fallback simpler style when not using motivator
         text_styles = [
             "naturally integrated into the scene",
             "as part of a document or sign in the image",
@@ -2573,15 +2601,25 @@ NICHE: GLP-1 / Weight Loss
 - People should be relatable, not fitness models
 - Confidence and lifestyle improvement focus"""
         
-        prompt = f"""Create a Facebook ad image with natural, authentic content.
-
-=== CAMERA QUALITY ===
-- The image should look like it was shot from a low quality camera
-- Include characteristics of low quality camera: slight grain, reduced sharpness, lower resolution appearance, authentic camera imperfections
-- Should have the authentic feel of a real photo taken with a basic or older camera device
-
-=== HEADLINE TEXT (if included, should be part of natural scene) ===
-"{headline}"
+        if use_motivator:
+            text_section = f'''=== MOTIVATOR PHRASE (blend naturally into the scene) ===
+Phrase: "{text_on_image}"
+
+CRITICAL — natural blend only:
+- Weave this phrase into the scene so it feels organic, not overlaid or forced.
+- It could appear {text_blend}.
+- The scene and concept come first; the phrase should feel like a natural part of that world.
+- No banners, boxes, or decorative overlays. No "ad-like" text placement.
+- Text must be READABLE and correctly spelled, but never the dominant focal point.
+- Avoid centering the phrase or making it look pasted on. It should belong in the environment.'''
+            layout_section = f"""=== LAYOUT ===
+- Prioritize the scene from the brief and the {concept.get('name')} concept.
+- The phrase "{text_on_image}" may appear anywhere it fits naturally (e.g. on a device, note, sign, or surface in frame).
+- Do NOT force a dedicated "text zone." Let the composition feel organic."""
+            closing = f'''Create a scroll-stopping, authentic image. The phrase "{text_on_image}" may appear naturally in the scene—never forced or overlay-style.'''
+        else:
+            text_section = f'''=== HEADLINE TEXT (if included, should be part of natural scene) ===
+"{text_on_image}"
 
 TEXT REQUIREMENTS (natural integration, NOT overlay):
 - Text should appear as part of the scene (on documents, signs, surfaces)
@@ -2589,7 +2627,20 @@ TEXT REQUIREMENTS (natural integration, NOT overlay):
 - Must be READABLE
 - Spell every word correctly
 - CRITICAL: NO overlay boxes, banners, or decorative elements
-- Text should look like it naturally belongs in the scene
+- Text should look like it naturally belongs in the scene'''
+            layout_section = f"""=== LAYOUT ===
+- Text zone (bottom 25%): "{text_on_image}"
+- Visual zone (top 75%): Scene following {concept.get('name')} concept"""
+            closing = f'''Create a scroll-stopping ad image with "{text_on_image}" prominently displayed.'''
+
+        prompt = f"""Create a Facebook ad image with natural, authentic content.
+
+=== CAMERA QUALITY ===
+- The image should look like it was shot from a low quality camera
+- Include characteristics of low quality camera: slight grain, reduced sharpness, lower resolution appearance, authentic camera imperfections
+- Should have the authentic feel of a real photo taken with a basic or older camera device
+
+{text_section}
 
 === VISUAL CONCEPT: {concept.get('name')} ===
 Structure: {concept.get('structure')}
@@ -2614,9 +2665,7 @@ If this image includes people or faces, they MUST look like real, original peopl
 - Faces that look like real photographs of real people, NOT AI-generated portraits
 - Avoid any faces that look synthetic, fake, or obviously computer-generated
 
-=== LAYOUT ===
-- Text zone (bottom 25%): "{headline}"
-- Visual zone (top 75%): Scene following {concept.get('name')} concept
+{layout_section}
 
 === AVOID ===
 - Missing or misspelled text
@@ -2631,8 +2680,9 @@ If this image includes people or faces, they MUST look like real, original peopl
 - Faces that look like they came from a face generator
 - Overly perfect, flawless skin
 - Cartoon-like or stylized faces
+{chr(10) + "- Forced or overlay-style text; the motivator must feel naturally mixed into the scene" if use_motivator else ""}
 
-Create a scroll-stopping ad image with "{headline}" prominently displayed."""
+{closing}"""
         
         # Refine and clean the prompt before sending (pass niche for demographic fixes)
         refined_prompt = self._refine_image_prompt(prompt, niche=niche)

services/motivator.py

@@ -0,0 +1,118 @@
+"""
+Motivator service: generate multiple motivators from niche + angle + concept context.
+Used in Matrix mode: user picks angle/concept, we generate motivators, user selects one for ad generation.
+"""
+
+import os
+import sys
+from typing import Dict, Any, List, Optional
+
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+from services.llm import llm_service
+
+
+async def generate_motivators(
+    niche: str,
+    angle: Dict[str, Any],
+    concept: Dict[str, Any],
+    target_audience: Optional[str] = None,
+    offer: Optional[str] = None,
+    count: int = 6,
+) -> List[str]:
+    """
+    Generate multiple emotional motivators using niche, angle, and concept as context.
+
+    Args:
+        niche: Target niche (e.g. home_insurance, glp1).
+        angle: Angle dict with name, trigger, example.
+        concept: Concept dict with name, structure, visual.
+        target_audience: Optional audience description.
+        offer: Optional offer description.
+        count: Number of motivators to generate (default 6).
+
+    Returns:
+        List of motivator strings (short, hook-ready, in customer's internal voice).
+    """
+    angle_name = angle.get("name", "Unknown")
+    angle_trigger = angle.get("trigger", "")
+    angle_example = angle.get("example", "")
+    concept_name = concept.get("name", "Unknown")
+    concept_structure = concept.get("structure", "")
+    concept_visual = concept.get("visual", "")
+
+    extra = []
+    if target_audience:
+        extra.append(f"Target audience: {target_audience}")
+    if offer:
+        extra.append(f"Offer: {offer}")
+    extra_block = "\n".join(extra) if extra else ""
+
+    system = """You are a marketing strategist who uncovers the deepest emotional motivators behind purchases.
+Output only motivators: short, punchy statements in the customer's internal voice (first-person).
+Each motivator should feel like a hidden truth—resentment, shame, betrayal, avoided identity, or unspoken truth.
+No features, no demographics. Emotional truths only. Keep each to 7–12 words where possible."""
+
+    prompt = f"""Niche: {niche.replace("_", " ").title()}
+
+ANGLE (psychological WHY):
+- Name: {angle_name}
+- Trigger: {angle_trigger}
+- Example: "{angle_example}"
+
+CONCEPT (visual HOW):
+- Name: {concept_name}
+- Structure: {concept_structure}
+- Visual: {concept_visual}
+{f"\n{extra_block}" if extra_block else ""}
+
+Generate exactly {count} distinct emotional motivators that fit this angle and concept.
+Each motivator = one short statement, customer's internal voice.
+Output as a JSON array of strings only, e.g. ["Motivator 1", "Motivator 2", ...].
+No numbering, no explanations."""
+
+    raw = await llm_service.generate(
+        prompt=prompt,
+        system_prompt=system,
+        temperature=0.75,
+    )
+
+    motivators = _parse_motivators(raw, count)
+    return motivators[:count]
+
+
+def _parse_motivators(raw: str, max_count: int) -> List[str]:
+    """Parse LLM output into a list of motivator strings."""
+    import json
+    import re
+
+    s = raw.strip()
+    # Strip markdown code blocks
+    for prefix in ("```json", "```"):
+        if s.lower().startswith(prefix):
+            s = s[len(prefix) :].lstrip()
+        if s.endswith("```"):
+            s = s[: -3].rstrip()
+
+    try:
+        out = json.loads(s)
+        if isinstance(out, list):
+            return [str(x).strip().strip('"').strip("'") for x in out if x]
+        if isinstance(out, dict) and "motivators" in out:
+            arr = out["motivators"]
+            return [str(x).strip().strip('"').strip("'") for x in arr if x]
+    except json.JSONDecodeError:
+        pass
+
+    # Fallback: line-based extraction
+    result = []
+    for line in s.splitlines():
+        line = line.strip()
+        if not line:
+            continue
+        # Remove leading "1.", "- ", "* ", etc.
+        line = re.sub(r"^\s*[\d\-*]+\.[\s)]*", "", line).strip()
+        line = line.strip('"').strip("'").strip()
+        if len(line) > 10:
+            result.append(line)
+    return result[:max_count]