Enhance prompt validation and safety features

- Added new endpoints for prompt validation and safety checks in `prompt_validator.py` and `prompt_safety.py`.
- Implemented content validation to catch potential policy violations before prompt generation.
- Introduced automatic prompt sanitization to modify unsafe content while preserving intent.
- Updated the API to include streaming prompt generation using GPT-5.2 in `prompt_generation.py`.
- Removed the deprecated pricing endpoint in `pricing.py`.
- Added a new script `run-dev.sh` for easier development setup with auto-rebuild for the frontend.
- Updated `.gitignore` to include prompt cache directory and ensure proper asset serving in production.
- Enhanced error handling in `video_generation.py` to improve feedback on failures.

.gitignore

@@ -34,8 +34,10 @@ ENV/
 # Storage
 storage/images/*
 storage/videos/*
+storage/prompt_cache/*
 !storage/images/.gitkeep
 !storage/videos/.gitkeep
+!storage/prompt_cache/.gitkeep
 
 # IDE
 .vscode/

api/image_service.py

@@ -3,39 +3,59 @@ Image Service API endpoints
 Handles image compression, storage, and serving
 """
 
-from fastapi import APIRouter, HTTPException, Response, UploadFile, File
+from fastapi import APIRouter, HTTPException, Response, UploadFile, File, Query
 from fastapi.responses import JSONResponse
 from utils.storage import temp_images
 from utils.image_processor import compress_and_store_image
 import os
+import re
 
 router = APIRouter()
 
+# High-quality settings for reference/continuity frames (last frame of previous segment)
+REFERENCE_FRAME_QUALITY = 92
+REFERENCE_FRAME_MAX_WIDTH = 1920
+REFERENCE_FRAME_MAX_HEIGHT = 1080
+
+def _is_reference_frame_filename(filename: str) -> bool:
+    if not filename:
+        return False
+    name = filename.lower()
+    return bool(re.match(r"^(frame-|last-frame\.|whisper-frame-)", name) or "frame" in name and name.endswith((".jpg", ".jpeg", ".png")))
+
+
 @router.post("/upload-image")
-async def upload_image(file: UploadFile = File(...)):
+async def upload_image(
+    file: UploadFile = File(...),
+    reference: bool = Query(False, description="High quality for last-frame/reference uploads"),
+):
     """
-    Upload and host an image, returns public URL
+    Upload and host an image, returns public URL.
+    Use ?reference=true when uploading a continuity/reference frame (last frame of previous segment)
+    for higher quality and less downscaling.
     """
     try:
-        # Read image bytes
         image_bytes = await file.read()
-        
-        # Convert to data URL for processing
         import base64
         encoded = base64.b64encode(image_bytes).decode('utf-8')
-        data_url = f"data:{file.content_type};base64,{encoded}"
-        
-        # Get public URL from env or use default
+        data_url = f"data:{file.content_type or 'image/jpeg'};base64,{encoded}"
         public_url = os.getenv('VITE_API_BASE_URL', 'http://localhost:4000')
-        
-        # Compress and store, get hosted URL
-        hosted_url = await compress_and_store_image(data_url, public_url)
-        
+
+        use_high_quality = reference or _is_reference_frame_filename(file.filename or "")
+        if use_high_quality:
+            hosted_url = await compress_and_store_image(
+                data_url, public_url,
+                max_width=REFERENCE_FRAME_MAX_WIDTH,
+                max_height=REFERENCE_FRAME_MAX_HEIGHT,
+                quality=REFERENCE_FRAME_QUALITY,
+            )
+        else:
+            hosted_url = await compress_and_store_image(data_url, public_url)
+
         return JSONResponse(content={
             "url": hosted_url,
-            "filename": file.filename
+            "filename": file.filename,
         })
-    
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Image upload failed: {str(e)}")
 

api/pricing.py

@@ -1,157 +0,0 @@
-"""Pricing endpoints for the frontend estimator
-
-Provides:
-- GET /pricing -> list of supported providers (id, name, summary)
-- POST /pricing/estimate -> estimated cost + breakdown + assumptions
-
-"""
-from fastapi import APIRouter, HTTPException
-from pydantic import BaseModel
-from typing import Optional, Dict, Any
-
-router = APIRouter()
-
-# Replicate `google/veo-3-fast` (with_audio): $0.15 / second
-# - equivalently: ~$10 / 66 seconds (user-provided)
-REPLICATE_VEO3_FAST_WITH_AUDIO = 0.15
-
-# KIE Veo 3 Fast (with audio): user-provided evidence: $0.40 for an 8s video
-# => $0.40 / 8s = $0.05 / second
-KIE_VEO3_FAST_WITH_AUDIO = 0.05
-
-# Provider catalogue for frontend list
-PROVIDERS = [
-    {"id": "kie", "name": "Kie API", "summary": "Veo 3.1 Fast (assumed audio)"},
-    {"id": "replicate", "name": "Replicate API", "summary": "google/veo-3-fast (with audio)"},
-    {"id": "openai", "name": "OpenAI", "summary": "Text & multimodal pricing"},
-]
-
-
-class PricingEstimateRequest(BaseModel):
-    provider: str
-    # seconds for video (optional for token-based providers)
-    video_seconds: Optional[float] = None
-    # quality / tier (optional)
-    quality: Optional[str] = None
-    # for token-based providers
-    input_tokens: Optional[int] = None
-    output_tokens: Optional[int] = None
-
-
-@router.get("/pricing")
-async def list_pricing_providers():
-    # Enrich provider list with sample pricing for common durations so
-    # the frontend can display costs on the provider cards without
-    # making multiple estimate requests.
-    def make_sample(pr_id: str):
-        if pr_id == 'replicate':
-            per_second = REPLICATE_VEO3_FAST_WITH_AUDIO
-            evidence = "model variant is with_audio — $0.15/sec (user-provided)"
-        elif pr_id == 'kie':
-            per_second = KIE_VEO3_FAST_WITH_AUDIO
-            evidence = "Veo 3 Fast (8s, with audio) — $0.40 per 8s (user-provided)"
-        else:
-            per_second = None
-            evidence = None
-
-        if per_second is None:
-            return {"per_second": None, "samples": {}, "evidence": evidence}
-
-        samples = {
-            "1s": round(per_second, 4),
-            "8s": round(per_second * 8, 4),
-            "30s": round(per_second * 30, 4),
-            "60s": round(per_second * 60, 4),
-        }
-        return {"per_second": per_second, "samples": samples, "evidence": evidence}
-
-    providers_with_pricing = []
-    for p in PROVIDERS:
-        info = p.copy()
-        pricing = make_sample(p['id'])
-        info['pricing'] = pricing
-        providers_with_pricing.append(info)
-
-    return {"providers": providers_with_pricing}
-
-
-@router.post("/pricing/estimate")
-async def estimate_pricing(req: PricingEstimateRequest) -> Dict[str, Any]:
-    """Return an approximate USD estimate, breakdown and assumptions.
-
-    Important: all video estimates assume audio is generated (product decision).
-    """
-    provider = (req.provider or "").lower()
-
-    if provider not in {"kie", "replicate", "openai"}:
-        raise HTTPException(status_code=400, detail="Unsupported provider")
-
-    # OpenAI (token-based) - pass through a simple token cost example
-    if provider == "openai":
-        input_t = req.input_tokens or 0
-        output_t = req.output_tokens or 0
-        # NOTE: these are illustrative values — frontend already marks assumptions
-        cost_per_input_1k = 3.00 / 1_000_000  # $3 / 1M input tokens -> per-token
-        cost_per_output_1k = 0.015 / 1_000    # $0.015 / 1k output tokens
-        estimated = input_t * cost_per_input_1k + output_t * cost_per_output_1k
-        return {
-            "estimated_cost_usd": round(estimated, 6),
-            "breakdown": {
-                "input_tokens": input_t,
-                "output_tokens": output_t,
-                "input_cost": round(input_t * cost_per_input_1k, 6),
-                "output_cost": round(output_t * cost_per_output_1k, 6),
-            },
-            "assumptions": {
-                "note": "Token pricing is illustrative — replace with your OpenAI contract rates",
-            }
-        }
-
-    # Video-based providers require `video_seconds`
-    if req.video_seconds is None:
-        raise HTTPException(status_code=400, detail="video_seconds is required for video providers")
-
-    seconds = float(req.video_seconds)
-
-    if provider == "replicate":
-        # Use published Veo 3 with_audio rate as conservative baseline
-        per_second = REPLICATE_VEO3_FAST_WITH_AUDIO
-        estimated = seconds * per_second
-        return {
-            "estimated_cost_usd": round(estimated, 6),
-            "breakdown": {
-                "per_second": per_second,
-                "seconds": seconds,
-                "line_item": round(seconds * per_second, 6)
-            },
-            "assumptions": {
-                "audio": True,
-                "model_variant": "with_audio",
-                "evidence_text": "model variant is with_audio — $0.15 per second of output video (or around 66 seconds for $10) — replicate google/veo-3-fast",
-                "source": "user-provided (project owner) — treated as authoritative for estimator",
-                "note": "google/veo-3-fast was provided as $0.15/sec (user). Replace if official published rate differs."
-            }
-        }
-
-    if provider == "kie":
-        # Use placeholder — must be replaced by an authoritative vendor rate
-        per_second = KIE_VEO3_FAST_WITH_AUDIO
-        estimated = seconds * per_second
-        return {
-            "estimated_cost_usd": round(estimated, 6),
-            "breakdown": {
-                "per_second": per_second,
-                "seconds": seconds,
-                "line_item": round(seconds * per_second, 6)
-            },
-            "assumptions": {
-                "audio": True,
-                "model_variant": "with_audio",
-                "evidence_text": "Veo 3 Fast (8 s, with audio) — Kie.ai $0.40 (≈$0.05/sec). About $0.40 per 8-second video with audio on Kie.ai.",
-                "source": "user-provided (project owner)",
-                "note": "KIE rate was supplied by project owner and used for estimator. Replace with vendor contract if different."
-            }
-        }
-
-    # Fallback
-    raise HTTPException(status_code=500, detail="Failed to compute estimate")

api/prompt_generation.py

@@ -1,44 +1,39 @@
 """
-GPT-4o Prompt Generation API
-Structured, validated segment generation for video prompts
+Prompt Generation API (streaming)
+Structured, validated segment generation for video prompts via GPT-5.2
 """
 
 from fastapi import APIRouter, HTTPException, UploadFile, File, Form
-from fastapi.responses import JSONResponse
-from pydantic import BaseModel
+from fastapi.responses import JSONResponse, StreamingResponse
 from typing import Optional
 import base64
+import asyncio
 
 from utils.prompt_generator import (
     VeoInputs,
-    generate_segments_payload,
-    split_script_into_segments
+    split_script_into_segments,
+    generate_single_segment,
+    generate_segment_plan_ai,
+    SEGMENT_DURATION_SECONDS,
+)
+from utils.prompt_cache import (
+    save_prompt,
+    get_prompt,
+    update_prompt,
+    list_prompts,
+    delete_prompt,
+    cleanup_old_prompts
 )
 from openai import OpenAI
 import os
 import json
+import uuid
 
 router = APIRouter()
 
 
-class PromptGenerationRequest(BaseModel):
-    """Request for prompt generation"""
-    script: str
-    style: str = "clean, lifestyle UGC"
-    jsonFormat: str = "standard"
-    continuationMode: bool = True
-    voiceType: Optional[str] = None
-    energyLevel: Optional[str] = None
-    settingMode: str = "single"
-    cameraStyle: Optional[str] = "handheld steadicam"
-    energyArc: Optional[str] = None
-    narrativeStyle: Optional[str] = "direct address"
-    accentRegion: Optional[str] = None
-    model: str = "gpt-4o"
-
-
-@router.post("/generate-prompts")
-async def generate_prompts_api(
+@router.post("/generate-prompts-stream")
+async def generate_prompts_stream(
     script: str = Form(...),
     style: str = Form("clean, lifestyle UGC"),
     jsonFormat: str = Form("standard"),
@@ -50,82 +45,225 @@ async def generate_prompts_api(
     energyArc: Optional[str] = Form(None),
     narrativeStyle: Optional[str] = Form("direct address"),
     accentRegion: Optional[str] = Form(None),
-    model: str = Form("gpt-4o"),
-    image: UploadFile = File(...)
+    model: str = Form("gpt-5.2"),
+    image: UploadFile = File(...),
+    segment_mode: str = Form("fixed"),
+    allowed_durations: Optional[str] = Form(None),
+    seconds_per_segment: int = Form(8),
 ):
     """
-    Generate structured video prompts using GPT-4o
+    🌊 STREAMING endpoint - Generate segments with real-time progress
     
     This endpoint:
-    1. Splits the script into 8-second segments
-    2. Generates detailed production prompts using GPT-4o
-    3. Validates the output against strict rules
-    4. Returns structured JSON for video generation
-    
-    Accepts multipart/form-data with:
-    - script: The video script text
-    - style: Visual style description
-    - image: Character reference image (required)
-    - Other optional parameters for fine-tuning
+    1. Streams each segment as it's generated (one-by-one)
+    2. Sends progress updates in real-time
+    3. Uses GPT-5.2 for individual segment generation
+    4. Provides immediate feedback to the frontend
     
     Returns:
-        Validated segments payload ready for video generation
+        Newline-delimited JSON (NDJSON) stream with events:
+        - "start": Initial event with total_segments
+        - "segment": Each generated segment with progress
+        - "complete": Final completion event
+        - "error": Error event if something fails
     """
+    
+    # 🔧 FIX: Read image BEFORE entering async generator
+    # The file handle will be closed by FastAPI after this function returns,
+    # so we must read the bytes into memory first
     try:
-        # Read image
         image_bytes = await image.read()
-        print(f"📷 Received reference image: {len(image_bytes)} bytes")
-        
-        # Convert continuationMode string to boolean
-        continuation_mode = continuationMode.lower() == "true"
-        
-        # Create inputs from form data
-        inputs = VeoInputs(
-            script=script,
-            style=style,
-            jsonFormat=jsonFormat,
-            continuationMode=continuation_mode,
-            voiceType=voiceType if voiceType else None,
-            energyLevel=energyLevel if energyLevel else None,
-            settingMode=settingMode,
-            cameraStyle=cameraStyle if cameraStyle else None,
-            energyArc=energyArc if energyArc else None,
-            narrativeStyle=narrativeStyle if narrativeStyle else None,
-            accentRegion=accentRegion if accentRegion else None
-        )
-        
-        # Check environment mode
-        environment = os.getenv('ENVIRONMENT', 'dev').lower()
-        is_dev_mode = environment == 'dev' or environment == 'development'
-        
-        # Generate payload
-        payload = generate_segments_payload(
-            inputs=inputs,
-            image_bytes=image_bytes,
-            model=model
-        )
-        
-        # Add environment mode to response
-        payload['environment'] = environment
-        payload['is_dev_mode'] = is_dev_mode
-        payload['max_segments'] = 2 if is_dev_mode else None
-        
-        # Validation warnings (if any) are logged to console but don't block
-        return JSONResponse(content=payload)
-    
+        print(f"📷 Received reference image for streaming: {len(image_bytes)} bytes")
     except Exception as e:
-        # API/network errors only (validation is non-blocking now)
-        raise HTTPException(
-            status_code=500,
-            detail=f"Prompt generation failed: {str(e)}"
-        )
+        print(f"❌ Failed to read image: {str(e)}")
+        async def error_stream():
+            yield json.dumps({
+                "event": "error",
+                "message": f"Failed to read image: {str(e)}",
+                "error_type": "ImageReadError"
+            }) + "\n"
+        return StreamingResponse(error_stream(), media_type="application/x-ndjson")
+    
+    async def stream_segments():
+        try:
+            
+            # Convert continuationMode string to boolean
+            continuation_mode = continuationMode.lower() == "true"
+            
+            # Create inputs from form data
+            inputs = VeoInputs(
+                script=script,
+                style=style,
+                jsonFormat=jsonFormat,
+                continuationMode=continuation_mode,
+                voiceType=voiceType if voiceType else None,
+                energyLevel=energyLevel if energyLevel else None,
+                settingMode=settingMode,
+                cameraStyle=cameraStyle if cameraStyle else None,
+                energyArc=energyArc if energyArc else None,
+                narrativeStyle=narrativeStyle if narrativeStyle else None,
+                accentRegion=accentRegion if accentRegion else None
+            )
+            
+            # Resolve segment list: AI-driven plan or fixed split
+            use_ai_plan = (segment_mode or "").strip().lower() == "ai_driven"
+            if use_ai_plan:
+                allowed = None
+                if allowed_durations:
+                    try:
+                        allowed = [int(x.strip()) for x in allowed_durations.split(",") if x.strip()]
+                        allowed = [d for d in allowed if d in SEGMENT_DURATION_SECONDS]
+                    except (ValueError, AttributeError):
+                        pass
+                plan = await generate_segment_plan_ai(
+                    script=script,
+                    style=style,
+                    allowed_durations=allowed or [4, 6, 8],
+                    model=model,
+                )
+                segment_texts = [p["dialogue"] for p in plan]
+                segment_durations = [p["duration_seconds"] for p in plan]
+                total_segments = len(plan)
+                print(f"🤖 AI plan: {total_segments} segments with durations {segment_durations}")
+            else:
+                seg_sec = 8
+                if seconds_per_segment in (4, 6, 8):
+                    seg_sec = seconds_per_segment
+                segment_texts = split_script_into_segments(script, seconds_per_segment=seg_sec)
+                segment_durations = [seg_sec] * len(segment_texts)
+                total_segments = len(segment_texts)
+            
+            print(f"🌊 Starting streaming generation of {total_segments} segments...")
+            
+            # 1. Send start event
+            yield json.dumps({
+                "event": "start",
+                "total_segments": total_segments,
+                "model": model,
+                "segment_mode": "ai_driven" if use_ai_plan else "fixed",
+            }) + "\n"
+            
+            # Store segments as we generate them
+            all_segments = []
+            reference_character = None
+            reference_scene = None
+            
+            # 2. Generate each segment individually and stream it
+            for i, segment_text in enumerate(segment_texts):
+                duration_sec = segment_durations[i] if i < len(segment_durations) else 8
+                print(f"🔄 Generating segment {i + 1}/{total_segments} ({duration_sec}s)...")
+                
+                try:
+                    # Generate THIS segment
+                    segment = await generate_single_segment(
+                        inputs=inputs,
+                        segment_text=segment_text,
+                        segment_index=i,
+                        total_segments=total_segments,
+                        image_bytes=image_bytes if i == 0 else None,  # Only send image for first segment
+                        reference_character=reference_character,
+                        reference_scene=reference_scene,
+                        segment_duration_seconds=duration_sec,
+                        model=model
+                    )
+                except Exception as seg_error:
+                    print(f"❌ Error generating segment {i + 1}: {str(seg_error)}")
+                    print(f"   Error type: {type(seg_error).__name__}")
+                    import traceback
+                    traceback.print_exc()
+                    raise  # Re-raise to be caught by outer try-except
+                
+                # Store for reference in subsequent segments
+                all_segments.append(segment)
+                
+                # Extract reference data from first segment for consistency
+                if i == 0:
+                    reference_character = segment.get("character_description", {})
+                    reference_scene = {
+                        "environment": segment.get("scene_continuity", {}).get("environment", ""),
+                        "lighting_state": segment.get("scene_continuity", {}).get("lighting_state", ""),
+                        "props_in_frame": segment.get("scene_continuity", {}).get("props_in_frame", ""),
+                        "background_elements": segment.get("scene_continuity", {}).get("background_elements", "")
+                    }
+                
+                # Calculate progress
+                progress = ((i + 1) / total_segments) * 100
+                
+                # 3. Stream this segment immediately
+                yield json.dumps({
+                    "event": "segment",
+                    "index": i,
+                    "total": total_segments,
+                    "segment": segment,
+                    "progress": round(progress, 2)
+                }) + "\n"
+                
+                print(f"✅ Streamed segment {i + 1}/{total_segments} ({progress:.1f}% complete)")
+                
+                # Small delay to ensure client receives the event
+                await asyncio.sleep(0.1)
+            
+            # 4. Build complete payload
+            payload = {
+                "segments": all_segments
+            }
+            
+            # Check environment mode
+            environment = os.getenv('ENVIRONMENT', 'dev').lower()
+            is_dev_mode = environment == 'dev' or environment == 'development'
+            
+            payload['environment'] = environment
+            payload['is_dev_mode'] = is_dev_mode
+            
+            # 5. Save to cache
+            prompt_id = str(uuid.uuid4())
+            save_prompt(
+                prompt_id=prompt_id,
+                payload=payload,
+                metadata={
+                    "script": script,
+                    "style": style,
+                    "model": model,
+                    "segments_count": total_segments,
+                    "generation_type": "streamed"
+                }
+            )
+            
+            payload['prompt_id'] = prompt_id
+            payload['cached'] = True
+            
+            print(f"💾 Saved streamed prompts to cache: {prompt_id}")
+            
+            # 6. Send completion event
+            yield json.dumps({
+                "event": "complete",
+                "message": f"Successfully generated {total_segments} segments",
+                "prompt_id": prompt_id,
+                "payload": payload
+            }) + "\n"
+            
+            print(f"✅ Streaming complete - {total_segments} segments generated")
+            
+        except Exception as e:
+            print(f"❌ Streaming error: {str(e)}")
+            # Send error event
+            yield json.dumps({
+                "event": "error",
+                "message": str(e),
+                "error_type": type(e).__name__
+            }) + "\n"
+    
+    return StreamingResponse(
+        stream_segments(),
+        media_type="application/x-ndjson"
+    )
 
 
 @router.post("/split-script")
 async def split_script_api(
     script: str = Form(...),
     seconds_per_segment: int = Form(8),
-    words_per_second: float = Form(2.2)
+    words_per_second: float = Form(2.5)
 ):
     """
     Split script into segments for preview
@@ -153,29 +291,36 @@ async def split_script_api(
 
 
 @router.post("/validate-payload")
-async def validate_payload_api(payload: dict):
+async def validate_payload_api(body: dict):
     """
-    Validate a segments payload against strict rules
+    Validate a segments payload (schema rules, optional AI review).
     
-    Use this to check if a manually created or modified payload is valid
+    Body can be:
+    - The payload itself: { "segments": [...] }  → returns schema validation only.
+    - Or: { "payload": { "segments": [...] }, "use_ai": true, "script": "optional" }  → schema + AI validation.
     """
     try:
-        from utils.prompt_generator import validate_segments_payload
-        
+        from utils.prompt_generator import validate_segments_payload, validate_segments_payload_with_ai
+
+        payload = body.get("payload") if "payload" in body else body
+        use_ai = body.get("use_ai", False)
+        script = body.get("script") or ""
+
+        if use_ai:
+            result = validate_segments_payload_with_ai(payload, script=script or None)
+            return {
+                "valid": result["valid"],
+                "schema_errors": result["schema_errors"],
+                "ai_checked": result["ai_checked"],
+                "ai_valid": result["ai_valid"],
+                "ai_warnings": result["ai_warnings"],
+                "ai_suggestions": result["ai_suggestions"],
+            }
         expected_segments = len(payload.get("segments", []))
         errors = validate_segments_payload(payload, expected_segments)
-        
         if errors:
-            return {
-                "valid": False,
-                "errors": errors
-            }
-        
-        return {
-            "valid": True,
-            "message": "Payload is valid"
-        }
-    
+            return {"valid": False, "errors": errors, "schema_errors": errors}
+        return {"valid": True, "message": "Payload is valid"}
     except Exception as e:
         raise HTTPException(
             status_code=500,
@@ -186,7 +331,7 @@ async def validate_payload_api(payload: dict):
 @router.get("/prompt-status")
 async def prompt_status():
     """
-    Check if GPT-4o prompt generation is available
+    Check if GPT-5.2 prompt generation is available
     """
     import os
     
@@ -194,7 +339,7 @@ async def prompt_status():
     
     return {
         "available": bool(openai_key),
-        "message": "GPT-4o is configured" if openai_key 
+        "message": "GPT-5.2 is configured" if openai_key
                    else "Add OPENAI_API_KEY to .env.local"
     }
 
@@ -208,8 +353,8 @@ async def refine_prompt_for_continuity(
 ):
     """
     Refine a segment prompt to match the actual visual AND audio from the previous segment.
-    
-    This ensures perfect continuity by having GPT-4o analyze:
+
+    This ensures perfect continuity by having GPT-5.2 analyze:
     1. The last frame (visual consistency)
     2. The transcribed dialogue (audio consistency - what was actually said)
     """
@@ -307,38 +452,56 @@ Return ONLY the updated JSON segment object with the same structure. No explanat
         
         print(f"🔄 Refining prompt for visual continuity...")
         
-        # Call GPT-4o with vision
-        response = client.chat.completions.create(
-            model="gpt-4o",
-            messages=[
-                {
-                    "role": "user",
-                    "content": [
-                        {
-                            "type": "text",
-                            "text": refinement_instructions
-                        },
-                        {
-                            "type": "image_url",
-                            "image_url": {
-                                "url": f"data:image/jpeg;base64,{encoded_image}"
-                            }
-                        }
-                    ]
-                }
-            ],
-            response_format={"type": "json_object"},
-            temperature=0.3,  # Lower temperature for precise matching
-        )
+        messages = [
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": refinement_instructions},
+                    {
+                        "type": "image_url",
+                        "image_url": {"url": f"data:image/jpeg;base64,{encoded_image}"}
+                    }
+                ]
+            }
+        ]
         
-        # Parse the response
-        refined_prompt = json.loads(response.choices[0].message.content)
+        content = None
+        for attempt in range(2):  # initial + 1 retry
+            response = client.chat.completions.create(
+                model="gpt-4o",
+                messages=messages,
+                response_format={"type": "json_object"},
+                temperature=0.3,
+            )
+            content = response.choices[0].message.content
+            if content and content.strip():
+                break
+            print(f"⚠️ GPT-4o returned empty response (attempt {attempt + 1}/2)")
+            if attempt == 0:
+                await asyncio.sleep(1.0)
         
-        print(f"✅ Prompt refined for visual continuity")
+        if not content or not content.strip():
+            print(f"⚠️ Using original segment after empty GPT response")
+            return JSONResponse(content={
+                "refined_prompt": segment_data,
+                "original_prompt": segment_data,
+                "refinement_skipped": True,
+            })
+        
+        try:
+            refined_prompt = json.loads(content)
+        except json.JSONDecodeError as je:
+            print(f"⚠️ Failed to parse GPT response as JSON, using original: {str(je)}")
+            return JSONResponse(content={
+                "refined_prompt": segment_data,
+                "original_prompt": segment_data,
+                "refinement_skipped": True,
+            })
         
+        print(f"✅ Prompt refined for visual continuity")
         return JSONResponse(content={
             "refined_prompt": refined_prompt,
-            "original_prompt": segment_data
+            "original_prompt": segment_data,
         })
     
     except Exception as e:
@@ -348,3 +511,223 @@ Return ONLY the updated JSON segment object with the same structure. No explanat
             detail=f"Prompt refinement failed: {str(e)}"
         )
 
+
+# ═══════════════════════════════════════════════════════════
+# 💾 PROMPT CACHE MANAGEMENT ENDPOINTS
+# ═══════════════════════════════════════════════════════════
+
+@router.get("/cached-prompts")
+async def list_cached_prompts(limit: int = 50):
+    """
+    List all cached prompts (most recent first)
+    
+    Query params:
+        limit: Maximum number of prompts to return (default: 50)
+    
+    Returns:
+        List of cached prompts with metadata
+    """
+    try:
+        prompts = list_prompts(limit=limit)
+        
+        # Return summary (without full payload for performance)
+        summaries = []
+        for p in prompts:
+            summaries.append({
+                "prompt_id": p["prompt_id"],
+                "created_at": p["created_at"],
+                "updated_at": p["updated_at"],
+                "metadata": p["metadata"],
+                "segments_count": len(p["payload"].get("segments", []))
+            })
+        
+        return {
+            "prompts": summaries,
+            "count": len(summaries)
+        }
+    
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to list cached prompts: {str(e)}"
+        )
+
+
+@router.get("/cached-prompts/{prompt_id}")
+async def get_cached_prompt(prompt_id: str):
+    """
+    Get a specific cached prompt with full payload
+    
+    Args:
+        prompt_id: The prompt identifier
+    
+    Returns:
+        Full cached prompt entry
+    """
+    try:
+        cache_entry = get_prompt(prompt_id)
+        
+        if not cache_entry:
+            raise HTTPException(
+                status_code=404,
+                detail=f"Prompt not found: {prompt_id}"
+            )
+        
+        return cache_entry
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to retrieve cached prompt: {str(e)}"
+        )
+
+
+@router.put("/cached-prompts/{prompt_id}")
+async def update_cached_prompt(prompt_id: str, payload: dict):
+    """
+    Update a cached prompt
+    
+    Args:
+        prompt_id: The prompt identifier
+        payload: Updated segments payload
+    
+    Returns:
+        Updated cache entry
+    """
+    try:
+        updated_entry = update_prompt(
+            prompt_id=prompt_id,
+            payload=payload
+        )
+        
+        if not updated_entry:
+            raise HTTPException(
+                status_code=404,
+                detail=f"Prompt not found: {prompt_id}"
+            )
+        
+        return {
+            "success": True,
+            "message": "Prompt updated successfully",
+            "prompt_id": prompt_id,
+            "updated_at": updated_entry["updated_at"]
+        }
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to update cached prompt: {str(e)}"
+        )
+
+
+@router.delete("/cached-prompts/{prompt_id}")
+async def delete_cached_prompt(prompt_id: str):
+    """
+    Delete a cached prompt
+    
+    Args:
+        prompt_id: The prompt identifier
+    
+    Returns:
+        Success message
+    """
+    try:
+        deleted = delete_prompt(prompt_id)
+        
+        if not deleted:
+            raise HTTPException(
+                status_code=404,
+                detail=f"Prompt not found: {prompt_id}"
+            )
+        
+        return {
+            "success": True,
+            "message": "Prompt deleted successfully",
+            "prompt_id": prompt_id
+        }
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to delete cached prompt: {str(e)}"
+        )
+
+
+@router.post("/cleanup-cache")
+async def cleanup_prompt_cache(max_age_days: int = 7):
+    """
+    Clean up old cached prompts
+    
+    Query params:
+        max_age_days: Maximum age in days (default: 7)
+    
+    Returns:
+        Cleanup summary
+    """
+    try:
+        cleanup_old_prompts(max_age_days=max_age_days)
+        
+        return {
+            "success": True,
+            "message": f"Cleaned up prompts older than {max_age_days} days"
+        }
+    
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Cache cleanup failed: {str(e)}"
+        )
+
+
+@router.post("/use-cached-prompt/{prompt_id}")
+async def use_cached_prompt_for_generation(prompt_id: str):
+    """
+    Retrieve a cached prompt for reuse in video generation
+    
+    This endpoint allows users to:
+    1. Recover from failed generations
+    2. Reuse previously generated prompts
+    3. Edit and regenerate with modifications
+    
+    Args:
+        prompt_id: The prompt identifier
+    
+    Returns:
+        The full payload ready for video generation
+    """
+    try:
+        cache_entry = get_prompt(prompt_id)
+        
+        if not cache_entry:
+            raise HTTPException(
+                status_code=404,
+                detail=f"Prompt not found: {prompt_id}"
+            )
+        
+        # Return the payload with cache metadata
+        response = {
+            "payload": cache_entry["payload"],
+            "metadata": cache_entry["metadata"],
+            "prompt_id": prompt_id,
+            "created_at": cache_entry["created_at"],
+            "from_cache": True
+        }
+        
+        print(f"♻️  Reusing cached prompt: {prompt_id}")
+        
+        return JSONResponse(content=response)
+    
+    except HTTPException:
+        raise
+    except Exception as e:
+        raise HTTPException(
+            status_code=500,
+            detail=f"Failed to retrieve cached prompt: {str(e)}"
+        )
+

api/prompt_safety.py

@@ -0,0 +1,205 @@
+"""
+Prompt Safety API - Auto-fix unsafe prompts
+Detects and sanitizes prompts that trigger content moderation errors
+"""
+
+from fastapi import APIRouter, HTTPException
+from pydantic import BaseModel
+from typing import Any, Dict
+import os
+import json
+from .veo_error_handler import (
+    handle_veo_error,
+    should_auto_fix,
+    is_safety_violation,
+    VeoErrorType
+)
+
+router = APIRouter()
+
+# Try importing OpenAI
+try:
+    from openai import OpenAI
+    OPENAI_AVAILABLE = True
+except ImportError:
+    OPENAI_AVAILABLE = False
+    print("⚠️ OpenAI package not available for prompt safety fixes")
+
+
+class SafetyFixRequest(BaseModel):
+    segment: Dict[str, Any]  # The VeoSegment that triggered safety error
+    error_message: str  # The error message from the API
+    attempt_count: int = 0  # How many times we've tried to fix this
+
+
+class SafetyFixResponse(BaseModel):
+    success: bool
+    fixed_segment: Dict[str, Any] | None = None
+    changes_made: str | None = None  # Description of what was changed
+    error: str | None = None
+
+
+def get_openai_client():
+    """Get OpenAI client"""
+    if not OPENAI_AVAILABLE:
+        raise HTTPException(
+            status_code=500,
+            detail="OpenAI package not installed"
+        )
+    
+    api_key = os.getenv('OPENAI_API_KEY')
+    if not api_key:
+        raise HTTPException(
+            status_code=500,
+            detail="OPENAI_API_KEY not configured"
+        )
+    
+    return OpenAI(api_key=api_key)
+
+
+@router.post("/fix-unsafe-prompt", response_model=SafetyFixResponse)
+async def fix_unsafe_prompt(request: SafetyFixRequest):
+    """
+    Automatically fix a prompt that triggered content safety errors.
+    
+    Uses GPT-4o to analyze the prompt and remove/modify content that
+    violates content policies while preserving the creative intent.
+    """
+    try:
+        client = get_openai_client()
+        
+        # Extract key parts of the segment
+        segment = request.segment
+        dialogue = segment.get('action_timeline', {}).get('dialogue', '')
+        character_state = segment.get('character_description', {}).get('current_state', '')
+        environment = segment.get('scene_continuity', {}).get('environment', '')
+        
+        # Build safety fix prompt for GPT
+        system_prompt = """You are a content safety expert. Your job is to modify video generation prompts that have been flagged as unsafe to make them compliant with content policies.
+
+Content policy violations typically include:
+- Violence, gore, or harmful content
+- Sexual or suggestive content
+- Hate speech or discriminatory content
+- Dangerous activities or illegal content
+- Disturbing or shocking imagery
+- References to prominent public figures, celebrities, or politicians (MOST COMMON!)
+- Copyrighted characters or brand names
+
+Based on official Veo 3.1 documentation, common safety violations include:
+- PUBLIC_ERROR_MINOR: Generic internal error (wait and retry)
+- Support Code errors: Specific safety categories (Child, Celebrity, Sexual, Violence, Dangerous)
+- "Flagged for containing a prominent public figure" - Replace names with generic descriptions
+
+Your task:
+1. Identify what might have triggered the safety filter
+2. Modify ONLY the problematic parts while preserving the overall scene intent
+3. Keep the modifications minimal - don't change the entire scene
+4. Maintain the emotional tone and storytelling intent
+5. Keep dialogue natural and character-appropriate
+6. Return the modified segment in the EXACT same JSON structure
+
+IMPORTANT FIXES FOR PUBLIC FIGURES:
+- Remove any names of real people, celebrities, politicians, or public figures
+- Replace with generic descriptions (e.g., "a business professional" instead of specific names)
+- Remove brand names or copyrighted characters
+- Keep the scene's intent but make it generic
+
+IMPORTANT: Make surgical changes - only fix what's unsafe, keep everything else."""
+
+        user_prompt = f"""A video generation prompt was flagged as unsafe with this error:
+"{request.error_message}"
+
+Original segment:
+```json
+{json.dumps(segment, indent=2)}
+```
+
+Please fix this segment by making MINIMAL changes to remove unsafe content while preserving the creative intent. Return the fixed segment in the exact same JSON structure.
+
+Think about:
+- What specific words or descriptions might have triggered the filter?
+- Are there any names of real people, celebrities, politicians, or public figures? Replace with generic roles.
+- Are there any brand names or copyrighted characters? Make them generic.
+- Can you replace violent/sexual/disturbing language with safer alternatives?
+- Can you soften intense emotional descriptions while keeping the mood?
+- Can you make actions less explicit while maintaining the story?
+
+Examples of fixes:
+- "Donald Trump gives a speech" → "A business executive gives a presentation"
+- "Like Elon Musk, he..." → "Like a tech entrepreneur, he..."
+- "Taylor Swift performs" → "A singer performs"
+- "Nike shoes" → "athletic shoes"
+- "Spider-Man" → "a superhero"
+
+Return ONLY the fixed JSON segment, no explanations."""
+
+        # Call GPT-4o to fix the prompt
+        print(f"🛡️ Attempting to auto-fix unsafe prompt (attempt {request.attempt_count + 1})...")
+        
+        response = client.chat.completions.create(
+            model="gpt-4o",
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt}
+            ],
+            temperature=0.3,  # Lower temperature for more conservative fixes
+            response_format={"type": "json_object"}
+        )
+        
+        # Parse the fixed segment
+        fixed_content = response.choices[0].message.content
+        if not fixed_content:
+            raise ValueError("Empty response from GPT")
+        
+        fixed_segment = json.loads(fixed_content)
+        
+        # Generate a summary of changes
+        changes = []
+        if fixed_segment.get('action_timeline', {}).get('dialogue') != dialogue:
+            changes.append("Modified dialogue for safety")
+        if fixed_segment.get('character_description', {}).get('current_state') != character_state:
+            changes.append("Adjusted character description")
+        if fixed_segment.get('scene_continuity', {}).get('environment') != environment:
+            changes.append("Softened scene environment")
+        
+        changes_summary = ", ".join(changes) if changes else "Made minimal safety adjustments"
+        
+        print(f"✅ Auto-fix complete: {changes_summary}")
+        
+        return SafetyFixResponse(
+            success=True,
+            fixed_segment=fixed_segment,
+            changes_made=changes_summary,
+            error=None
+        )
+    
+    except json.JSONDecodeError as e:
+        error_msg = f"Failed to parse GPT response: {str(e)}"
+        print(f"❌ {error_msg}")
+        return SafetyFixResponse(
+            success=False,
+            fixed_segment=None,
+            changes_made=None,
+            error=error_msg
+        )
+    
+    except Exception as e:
+        error_msg = f"Safety fix failed: {str(e)}"
+        print(f"❌ {error_msg}")
+        return SafetyFixResponse(
+            success=False,
+            fixed_segment=None,
+            changes_made=None,
+            error=error_msg
+        )
+
+
+@router.get("/safety/health")
+async def safety_health():
+    """Check if safety fix is available"""
+    return {
+        "available": OPENAI_AVAILABLE and bool(os.getenv('OPENAI_API_KEY')),
+        "message": "Safety fix ready" if (OPENAI_AVAILABLE and os.getenv('OPENAI_API_KEY'))
+                   else "OpenAI not configured"
+    }

api/prompt_validator.py

@@ -0,0 +1,155 @@
+"""
+Pre-submission prompt validation to catch common issues before generation
+"""
+
+import re
+from typing import Dict, List, Tuple
+
+# Common public figure names (not exhaustive, just examples)
+COMMON_PUBLIC_FIGURES = [
+    # Politicians
+    "donald trump", "joe biden", "barack obama", "kamala harris",
+    "vladimir putin", "xi jinping", "narendra modi", "boris johnson",
+    # Tech CEOs
+    "elon musk", "jeff bezos", "mark zuckerberg", "bill gates", "steve jobs",
+    "tim cook", "sundar pichai", "satya nadella",
+    # Celebrities
+    "taylor swift", "beyonce", "kim kardashian", "kanye west",
+    "dwayne johnson", "tom cruise", "leonardo dicaprio",
+    # Athletes
+    "lebron james", "cristiano ronaldo", "lionel messi", "serena williams",
+    "tiger woods", "michael jordan",
+]
+
+# Copyrighted characters and brands
+COPYRIGHTED_TERMS = [
+    # Characters
+    "spider-man", "spiderman", "batman", "superman", "iron man",
+    "mickey mouse", "harry potter", "darth vader",
+    # Brands
+    "nike", "adidas", "apple", "google", "microsoft", "coca-cola",
+    "pepsi", "mcdonalds", "starbucks", "amazon",
+]
+
+
+def validate_prompt_content(text: str) -> Tuple[bool, List[str]]:
+    """
+    Validate prompt content for potential content policy violations.
+    
+    Returns:
+        Tuple of (is_valid, list_of_warnings)
+    """
+    warnings = []
+    text_lower = text.lower()
+    
+    # Check for public figures
+    found_figures = [name for name in COMMON_PUBLIC_FIGURES if name in text_lower]
+    if found_figures:
+        warnings.append(
+            f"⚠️ Detected public figure(s): {', '.join(found_figures)}. "
+            "Consider using generic descriptions instead (e.g., 'a business executive' instead of specific names)."
+        )
+    
+    # Check for copyrighted terms
+    found_copyrighted = [term for term in COPYRIGHTED_TERMS if term in text_lower]
+    if found_copyrighted:
+        warnings.append(
+            f"⚠️ Detected copyrighted term(s): {', '.join(found_copyrighted)}. "
+            "Consider using generic alternatives to avoid content policy issues."
+        )
+    
+    # Check for potentially sensitive content
+    sensitive_patterns = [
+        (r'\b(kill|murder|death|blood|violence)\b', "violent content"),
+        (r'\b(naked|nude|sex|sexual)\b', "explicit content"),
+        (r'\b(hate|racist|discriminat)\w*\b', "discriminatory language"),
+    ]
+    
+    for pattern, content_type in sensitive_patterns:
+        if re.search(pattern, text_lower):
+            warnings.append(f"⚠️ Potentially sensitive {content_type} detected. Review for content policy compliance.")
+    
+    is_valid = len(warnings) == 0
+    return is_valid, warnings
+
+
+def sanitize_prompt_content(text: str) -> str:
+    """
+    Automatically sanitize prompt content by replacing problematic terms.
+    This is a basic implementation - the AI-powered fix is more sophisticated.
+    
+    Returns:
+        Sanitized text
+    """
+    sanitized = text
+    
+    # Replace common public figures with generic terms
+    replacements = {
+        # Politicians
+        "donald trump": "a business executive",
+        "joe biden": "a senior politician",
+        "elon musk": "a tech entrepreneur",
+        "jeff bezos": "a business mogul",
+        "mark zuckerberg": "a tech founder",
+        "bill gates": "a technology pioneer",
+        # Celebrities
+        "taylor swift": "a popular singer",
+        "beyonce": "a renowned performer",
+        "kim kardashian": "a media personality",
+        # Athletes
+        "lebron james": "a professional basketball player",
+        "cristiano ronaldo": "a soccer star",
+        "lionel messi": "a soccer champion",
+        # Characters
+        "spider-man": "a superhero",
+        "spiderman": "a superhero",
+        "batman": "a crime fighter",
+        "superman": "a hero with superpowers",
+        "harry potter": "a young wizard",
+        # Brands
+        "nike": "athletic",
+        "adidas": "sportswear",
+        "apple": "tech",
+        "google": "a search engine",
+        "starbucks": "a coffee shop",
+        "mcdonalds": "a restaurant",
+    }
+    
+    for term, replacement in replacements.items():
+        # Case-insensitive replacement
+        pattern = re.compile(re.escape(term), re.IGNORECASE)
+        sanitized = pattern.sub(replacement, sanitized)
+    
+    return sanitized
+
+
+def get_content_guidance() -> Dict[str, List[str]]:
+    """
+    Get guidance on what to avoid in prompts.
+    
+    Returns:
+        Dictionary of content categories and examples
+    """
+    return {
+        "avoid_public_figures": [
+            "Real politicians, celebrities, athletes, or public figures",
+            "Use generic roles instead: 'a business executive', 'a singer', 'an athlete'",
+        ],
+        "avoid_copyrighted": [
+            "Trademarked characters (Spider-Man, Mickey Mouse, etc.)",
+            "Brand names (Nike, Apple, Starbucks, etc.)",
+            "Use generic alternatives: 'a superhero', 'athletic shoes', 'a coffee shop'",
+        ],
+        "avoid_sensitive": [
+            "Violence, gore, or disturbing imagery",
+            "Explicit or sexual content",
+            "Hate speech or discriminatory language",
+            "Dangerous or illegal activities",
+        ],
+        "best_practices": [
+            "Use generic, descriptive language",
+            "Focus on actions, emotions, and settings rather than specific identities",
+            "Keep content family-friendly and brand-safe",
+            "Test with shorter scripts first to validate content compliance",
+        ],
+    }

api/veo_error_handler.py

@@ -0,0 +1,272 @@
+"""
+Veo 3.1 Official Error Handler
+Based on official Veo 3.1 API documentation
+"""
+
+from enum import Enum
+from typing import Dict, Tuple, Optional
+import re
+
+
+class VeoErrorType(Enum):
+    """Official Veo 3.1 error types"""
+    RESOURCE_EXHAUSTED = "429"
+    FORBIDDEN = "403"
+    SAFETY_FILTER = "safety"
+    PUBLIC_ERROR_MINOR = "public_error_minor"
+    CELEBRITY = "celebrity"  # Prominent public figure
+    CHILD = "child"
+    SEXUAL = "sexual"
+    VIOLENCE = "violence"
+    DANGEROUS = "dangerous"
+    UNKNOWN = "unknown"
+
+
+# Official Veo 3.1 Safety Filter Support Codes
+# Source: Official API Documentation
+SAFETY_CODES: Dict[str, str] = {
+    # Child Safety
+    "58061214": "Child",
+    "17301594": "Child",
+    
+    # Celebrity / Public Figures
+    "29310472": "Celebrity",
+    "15236754": "Celebrity",
+    
+    # Sexual Content
+    "90789179": "Sexual",
+    "43188360": "Sexual",
+    
+    # Violence
+    "61493863": "Violence",
+    "56562880": "Violence",
+    
+    # Dangerous Content
+    "62263041": "Dangerous",
+}
+
+
+def extract_support_code(error_message: str) -> Optional[str]:
+    """
+    Extract 8-digit support code from error message
+    
+    Args:
+        error_message: The error message from Veo API
+        
+    Returns:
+        Support code if found, None otherwise
+    """
+    # Look for 8-digit numbers (support codes)
+    match = re.search(r'\b\d{8}\b', error_message)
+    return match.group(0) if match else None
+
+
+def get_safety_category(support_code: str) -> str:
+    """
+    Get safety category from support code
+    
+    Args:
+        support_code: 8-digit support code
+        
+    Returns:
+        Safety category name
+    """
+    return SAFETY_CODES.get(support_code, f"Unknown ({support_code})")
+
+
+def is_safety_violation(error_message: str) -> bool:
+    """
+    Check if error is a safety filter violation
+    
+    Args:
+        error_message: Error message from API
+        
+    Returns:
+        True if safety violation detected
+    """
+    # Official keywords from documentation
+    safety_keywords = [
+        "safety filter",
+        "safety violation",
+        "content policy",
+        "inappropriate content",
+        "flagged for containing",
+        "prominent public figure",
+        "celebrity",
+        "public figure",
+        "politician",
+        "moderation",
+    ]
+    
+    error_lower = error_message.lower()
+    
+    # Check for keywords
+    if any(keyword in error_lower for keyword in safety_keywords):
+        return True
+    
+    # Check for support code
+    if extract_support_code(error_message):
+        return True
+    
+    return False
+
+
+def is_public_error_minor(error_message: str) -> bool:
+    """
+    Check if error is PUBLIC_ERROR_MINOR (generic internal error)
+    
+    Args:
+        error_message: Error message from API
+        
+    Returns:
+        True if PUBLIC_ERROR_MINOR detected
+    """
+    return "PUBLIC_ERROR_MINOR" in error_message.upper()
+
+
+def handle_veo_error(error_response: Dict) -> Tuple[VeoErrorType, str, Optional[str]]:
+    """
+    Handle Veo 3.1 errors according to official documentation
+    
+    Args:
+        error_response: Error response from Veo API
+        
+    Returns:
+        Tuple of (error_type, error_message, support_code)
+    """
+    error_code = str(error_response.get("code", ""))
+    error_message = error_response.get("message", "")
+    
+    # Extract support code if present
+    support_code = extract_support_code(error_message)
+    
+    # 429: Too many requests
+    if "429" in error_code:
+        return (
+            VeoErrorType.RESOURCE_EXHAUSTED,
+            "Too many requests. Wait 5-10 minutes and retry.",
+            None
+        )
+    
+    # 403: Insufficient permissions
+    if "403" in error_code:
+        return (
+            VeoErrorType.FORBIDDEN,
+            "Insufficient permissions. Check API configuration.",
+            None
+        )
+    
+    # PUBLIC_ERROR_MINOR: Generic internal error
+    if is_public_error_minor(error_message):
+        return (
+            VeoErrorType.PUBLIC_ERROR_MINOR,
+            "Internal processing error. Wait 5-10 minutes or simplify request.",
+            None
+        )
+    
+    # Safety filter with support code
+    if support_code:
+        category = get_safety_category(support_code)
+        return (
+            VeoErrorType.SAFETY_FILTER,
+            f"Safety filter triggered: {category}",
+            support_code
+        )
+    
+    # Celebrity / Public Figure (no support code)
+    if any(keyword in error_message.lower() for keyword in [
+        "prominent public figure", "celebrity", "politician", "public figure"
+    ]):
+        return (
+            VeoErrorType.CELEBRITY,
+            "Content contains prominent public figure or celebrity",
+            None
+        )
+    
+    # Generic safety violation
+    if is_safety_violation(error_message):
+        return (
+            VeoErrorType.SAFETY_FILTER,
+            "Content policy violation detected",
+            None
+        )
+    
+    # Unknown error
+    return (
+        VeoErrorType.UNKNOWN,
+        error_message or "Unknown error occurred",
+        None
+    )
+
+
+def get_retry_strategy(error_type: VeoErrorType) -> Dict[str, any]:
+    """
+    Get recommended retry strategy for error type
+    
+    Args:
+        error_type: The type of error
+        
+    Returns:
+        Dict with retry strategy
+    """
+    strategies = {
+        VeoErrorType.RESOURCE_EXHAUSTED: {
+            "should_retry": True,
+            "wait_seconds": 600,  # 10 minutes
+            "max_retries": 2,
+            "requires_fix": False,
+        },
+        VeoErrorType.PUBLIC_ERROR_MINOR: {
+            "should_retry": True,
+            "wait_seconds": 300,  # 5 minutes
+            "max_retries": 2,
+            "requires_fix": False,
+        },
+        VeoErrorType.CELEBRITY: {
+            "should_retry": True,
+            "wait_seconds": 2,
+            "max_retries": 2,
+            "requires_fix": True,  # Needs AI fix
+        },
+        VeoErrorType.SAFETY_FILTER: {
+            "should_retry": True,
+            "wait_seconds": 2,
+            "max_retries": 2,
+            "requires_fix": True,  # Needs AI fix
+        },
+        VeoErrorType.FORBIDDEN: {
+            "should_retry": False,
+            "wait_seconds": 0,
+            "max_retries": 0,
+            "requires_fix": False,
+        },
+        VeoErrorType.UNKNOWN: {
+            "should_retry": True,
+            "wait_seconds": 5,
+            "max_retries": 1,
+            "requires_fix": False,
+        },
+    }
+    
+    return strategies.get(error_type, strategies[VeoErrorType.UNKNOWN])
+
+
+def should_auto_fix(error_type: VeoErrorType) -> bool:
+    """
+    Determine if error should trigger AI auto-fix
+    
+    Args:
+        error_type: The type of error
+        
+    Returns:
+        True if auto-fix should be attempted
+    """
+    fixable_types = [
+        VeoErrorType.CELEBRITY,
+        VeoErrorType.SAFETY_FILTER,
+        VeoErrorType.CHILD,
+        VeoErrorType.SEXUAL,
+        VeoErrorType.VIOLENCE,
+        VeoErrorType.DANGEROUS,
+    ]
+    return error_type in fixable_types

api/video_generation.py

@@ -282,10 +282,13 @@ async def veo_callback(callback_data: CallbackData):
                 'fallbackFlag': fallback_flag
             })
         else:
+            # Include both code and message for proper error handling
+            # This format matches what veo_error_handler.py expects
             await send_sse_event(task_id, {
                 'status': 'failed',
-                'error': callback_data.msg,
-                'code': callback_data.code
+                'error': callback_data.msg,  # Legacy field
+                'message': callback_data.msg,  # For error handler
+                'code': callback_data.code  # HTTP or API error code
             })
         
         # Clean up old results

frontend/FLOW.md

@@ -378,7 +378,7 @@ USER INPUT                    BACKEND                         EXTERNAL APIs
 
 | Endpoint | Method | Description |
 |----------|--------|-------------|
-| `/api/generate-prompts` | POST | GPT-4o script analysis & segmentation |
+| `/api/generate-prompts-stream` | POST | Streaming prompt generation (GPT-5.2) |
 | `/api/upload-image` | POST | Upload character reference image |
 | `/api/veo/generate` | POST | Start video generation |
 | `/api/veo/extend` | POST | Extend existing video |

frontend/README.md

@@ -26,11 +26,23 @@ cd frontend
 # Install dependencies
 npm install
 
-# Start development server
+# Start development server (Vite dev server with HMR)
 npm run dev
 ```
 
-The frontend will be available at `http://localhost:3000`.
+The frontend will be available at `http://localhost:5173` (Vite default).
+
+### Serving from Python backend (port 4000)
+
+If you want to use the app at `http://localhost:4000` (same origin as the API):
+
+- **One-time build:** `npm run build` then start the backend with `python main.py`.
+- **Auto-rebuild on save:** run from project root:
+  ```bash
+  bash run-dev.sh
+  ```
+  This starts the backend and runs `npm run build:watch` so any change in `frontend/src` triggers a rebuild; refresh the browser to see updates.
+- **Or in two terminals:** Terminal 1: `cd frontend && npm run build:watch`; Terminal 2: `python main.py`.
 
 ### Environment Variables
 
@@ -119,7 +131,7 @@ npm run preview
 
 The frontend communicates with the Python backend at `/api/*`:
 
-- `POST /api/generate-prompts` - Generate video prompts with GPT-4o
+- `POST /api/generate-prompts-stream` - Generate video prompts (streaming, GPT-5.2)
 - `POST /api/veo/generate` - Start Kling video generation
 - `GET /api/veo/events/:taskId` - SSE for generation progress
 - `POST /api/replicate/generate` - Start Replicate generation

frontend/package.json

@@ -6,6 +6,7 @@
   "scripts": {
     "dev": "vite",
     "build": "tsc && vite build",
+    "build:watch": "tsc && vite build --watch",
     "preview": "vite preview"
   },
   "dependencies": {

frontend/src/App.tsx

@@ -9,7 +9,8 @@ import {
   GenerationComplete,
   ErrorDisplay,
   Login,
-  LogoIcon 
+  LogoIcon,
+  SavedPromptsLibrary 
 } from '@/components';
 import { checkHealth } from '@/utils/api';
 import type { HealthStatus } from '@/types';
@@ -17,9 +18,10 @@ import type { HealthStatus } from '@/types';
 // Main App Content (uses context)
 function AppContent() {
   const { isAuthenticated, loading: authLoading, logout } = useAuth();
-  const { state, selectProvider, reset } = useGeneration();
+  const { state, selectProvider, reset, updateSegments } = useGeneration();
   const [healthStatus, setHealthStatus] = useState<HealthStatus | null>(null);
   const [healthError, setHealthError] = useState<string | null>(null);
+  const [showSavedPrompts, setShowSavedPrompts] = useState(false);
 
   // Check backend health on mount (must be called before any conditional returns)
   useEffect(() => {
@@ -138,6 +140,17 @@ function AppContent() {
                 </span>
               </div>
 
+              {/* Saved Prompts Button */}
+              <button
+                onClick={() => setShowSavedPrompts(true)}
+                className="px-3 py-1.5 text-xs font-medium text-void-400 hover:text-void-200 
+                         hover:bg-void-800 rounded-lg transition-colors flex items-center gap-1.5"
+                title="My Saved Prompts"
+              >
+                <span>💾</span>
+                <span>Saved Prompts</span>
+              </button>
+
               {/* Logout Button */}
               <button
                 onClick={logout}
@@ -174,6 +187,67 @@ function AppContent() {
           <span className="text-coral-400">AdGenesis</span>
         </p>
       </footer>
+
+      {/* Saved Prompts Modal */}
+      {showSavedPrompts && (
+        <SavedPromptsLibrary
+          onClose={() => setShowSavedPrompts(false)}
+          onReuse={(data) => {
+            // Handle reusing a saved prompt - skip prompt generation, go directly to video generation
+            console.log('♻️ Reusing cached prompt:', data);
+            setShowSavedPrompts(false);
+            
+            // Extract segments - check multiple possible locations for robustness
+            let segments = data.payload?.segments || data.segments || [];
+            
+            // If segments is still empty, try to find it in the data structure
+            if (segments.length === 0 && data.payload) {
+              // Sometimes the entire payload is the segments object
+              const payload = data.payload;
+              if (Array.isArray(payload)) {
+                segments = payload;
+              } else if (typeof payload === 'object') {
+                // Check if any property contains an array of segments
+                for (const key of Object.keys(payload)) {
+                  if (Array.isArray(payload[key]) && payload[key].length > 0) {
+                    // Verify it looks like segments (has segment_info or character_description)
+                    const firstItem = payload[key][0];
+                    if (firstItem && (firstItem.segment_info || firstItem.character_description)) {
+                      segments = payload[key];
+                      break;
+                    }
+                  }
+                }
+              }
+            }
+            
+            console.log('📊 Extracted segments:', segments);
+            console.log('📊 Segments count:', segments.length);
+            
+            if (segments.length === 0) {
+              console.error('❌ No segments found in data structure:', data);
+              alert('No segments found in cached prompt. Please check the console for details.');
+              return;
+            }
+            
+            // Determine provider from metadata or default to kling
+            const provider = data.metadata?.provider || 'kling';
+            
+            console.log(`🚀 Loading ${segments.length} cached segments for ${provider}`);
+            
+            // IMPORTANT: Load segments FIRST, then set provider
+            // This ensures segments are available when the form renders
+            updateSegments(segments);
+            
+            // Small delay to ensure state update has propagated
+            setTimeout(() => {
+              selectProvider(provider);
+            }, 50);
+            
+            // The form will detect the pre-loaded segments and skip prompt generation
+          }}
+        />
+      )}
     </div>
   );
 }

frontend/src/components/ErrorDisplay.tsx

@@ -4,7 +4,10 @@ import { XIcon, RefreshIcon, ArrowLeftIcon } from './Icons';
 
 export const ErrorDisplay: React.FC = () => {
   const { state, reset, setStep } = useGeneration();
-  const { error } = state;
+  const { error, generatedVideos, segments } = state;
+  const isCancelled = error?.toLowerCase().includes('cancelled') ?? false;
+  const hasPartialVideos = generatedVideos.length > 0;
+  const hasPartialPrompts = segments.length > 0 && !hasPartialVideos;
 
   return (
     <motion.div
@@ -23,17 +26,34 @@ export const ErrorDisplay: React.FC = () => {
           <XIcon size={40} className="text-red-400" />
         </motion.div>
 
-        {/* Error Message */}
+        {/* Title: Cancelled vs Failed */}
         <h1 className="text-3xl font-display font-bold text-void-100 mb-4">
-          Generation Failed
+          {isCancelled ? 'Generation Cancelled' : 'Generation Failed'}
         </h1>
-        
-        <div className="card bg-red-500/10 border-red-500/30 mb-8">
+
+        <div className="card bg-red-500/10 border-red-500/30 mb-4">
           <p className="text-red-300 text-sm">
             {error || 'An unexpected error occurred during video generation.'}
           </p>
         </div>
 
+        {/* Partial results when user cancelled */}
+        {(isCancelled && (hasPartialVideos || hasPartialPrompts)) && (
+          <div className="card bg-void-900/80 border-void-600 mb-8 text-left">
+            <h3 className="text-sm font-semibold text-void-200 mb-2">Stopped with partial results</h3>
+            {hasPartialVideos && (
+              <p className="text-void-300 text-sm">
+                <span className="font-medium text-void-100">{generatedVideos.length}</span> video segment{generatedVideos.length === 1 ? '' : 's'} generated.
+              </p>
+            )}
+            {hasPartialPrompts && (
+              <p className="text-void-300 text-sm mt-1">
+                <span className="font-medium text-void-100">{segments.length}</span> segment prompt{segments.length === 1 ? '' : 's'} generated (no videos yet).
+              </p>
+            )}
+          </div>
+        )}
+
         {/* Actions */}
         <div className="flex flex-col sm:flex-row items-center justify-center gap-4">
           <button

frontend/src/components/GenerationComplete.tsx

@@ -2,11 +2,12 @@ import { useState } from 'react';
 import { motion } from 'framer-motion';
 import { useGeneration } from '@/context/GenerationContext';
 import { CheckIcon, DownloadIcon, PlayIcon, RefreshIcon, VideoIcon } from './Icons';
+import { SegmentPromptsViewer } from './SegmentPromptsViewer';
 import { mergeVideos, ClipMetadata } from '@/utils/api';
 
 export const GenerationComplete: React.FC = () => {
   const { state, reset } = useGeneration();
-  const { generatedVideos, provider } = state;
+  const { generatedVideos, provider, segments, partialCompletionError } = state;
   const [playingIndex, setPlayingIndex] = useState<number | null>(null);
   const [isMerging, setIsMerging] = useState(false);
   const [mergeError, setMergeError] = useState<string | null>(null);
@@ -116,6 +117,30 @@ export const GenerationComplete: React.FC = () => {
       className="min-h-[60vh] flex flex-col items-center justify-center p-8"
     >
       <div className="max-w-4xl w-full">
+        {/* Partial Completion Warning */}
+        {partialCompletionError && (
+          <motion.div
+            initial={{ opacity: 0, y: -10 }}
+            animate={{ opacity: 1, y: 0 }}
+            className="mb-8 p-6 bg-gradient-to-r from-amber-500/10 to-red-500/10 border-2 border-amber-500/30 rounded-xl"
+          >
+            <div className="flex items-start gap-4">
+              <div className="flex-shrink-0 w-12 h-12 rounded-full bg-amber-500/20 flex items-center justify-center">
+                <span className="text-2xl">⚠️</span>
+              </div>
+              <div className="flex-1">
+                <h3 className="font-bold text-amber-300 mb-2 text-lg">Partial Generation</h3>
+                <p className="text-void-200 text-sm mb-3">
+                  {partialCompletionError}
+                </p>
+                <p className="text-void-400 text-xs">
+                  The successfully generated videos are displayed below. You can still export and use them.
+                </p>
+              </div>
+            </div>
+          </motion.div>
+        )}
+
         {/* Success Header */}
         <div className="text-center mb-12">
           <motion.div
@@ -140,7 +165,7 @@ export const GenerationComplete: React.FC = () => {
             className="text-4xl font-display font-bold mb-4"
           >
             <span className={accentColor === 'coral' ? 'gradient-text' : 'gradient-text-electric'}>
-              Generation Complete!
+              {partialCompletionError ? 'Partial Generation Complete' : 'Generation Complete!'}
             </span>
           </motion.h1>
           
@@ -219,6 +244,20 @@ export const GenerationComplete: React.FC = () => {
           ))}
         </motion.div>
 
+        {/* Segment Prompts Viewer */}
+        {segments.length > 0 && (
+          <motion.div
+            initial={{ opacity: 0, y: 20 }}
+            animate={{ opacity: 1, y: 0 }}
+            transition={{ delay: 0.5 }}
+          >
+            <SegmentPromptsViewer 
+              segments={segments} 
+              accentColor={accentColor}
+            />
+          </motion.div>
+        )}
+
         {/* Merged Video Preview */}
         {mergedVideoUrl && (
           <motion.div

frontend/src/components/GenerationForm.tsx

@@ -8,18 +8,28 @@ import {
   ImageIcon 
 } from './Icons';
 import { 
-  generatePrompts, 
+  generatePromptsStreaming,
+  type StreamEvent,
+  type StreamSegmentEvent,
   uploadImage, 
   klingGenerate, 
   klingExtend,
   waitForKlingVideo, 
   generateVideoWithRetry,
+  handleFlowRetry,
+  type FlowRetryOutcome,
   downloadVideo, 
   getVideoDuration,
   generateThumbnails,
   replicateGenerate,
   waitForReplicateVideo,
-  whisperAnalyzeAndExtract
+  whisperAnalyzeAndExtract,
+  fixUnsafePrompt,
+  isUnsafeSegmentError,
+  validateContent,
+  AUTO_FIX_MAX_ATTEMPTS,
+  MAX_VIDEO_ATTEMPTS,
+  type ContentValidationResponse
 } from '@/utils/api';
 
 interface GenerationFormProps {
@@ -37,8 +47,11 @@ const aspectRatios = ['9:16', '16:9', '1:1'];
 type GenerationMode = 'extend' | 'frame-continuity';
 
 export const GenerationForm: React.FC<GenerationFormProps> = ({ provider, onBack }) => {
-  const { startGeneration, updateProgress, addVideo, setStep, setError, setRetryState, updateSegments, addTaskId, removeTaskId, state } = useGeneration();
-  const { retryState, generatedVideos, segments, isCancelling } = state;
+  const { startGeneration, updateProgress, addVideo, setStep, setError, updateSegments, addTaskId, removeTaskId, setPartialCompletionError, registerPromptAbortController, state } = useGeneration();
+  const { generatedVideos, segments, isCancelling } = state;
+  
+  // Check if we're in "reuse mode" (segments pre-loaded from cache)
+  const isReuseMode = segments.length > 0;
   
   // Draft storage key
   const draftKey = `video-gen-draft-${provider}`;
@@ -78,73 +91,15 @@ export const GenerationForm: React.FC<GenerationFormProps> = ({ provider, onBack
   const [imagePreview, setImagePreview] = useState<string | null>(draft?.imagePreview || null);
   const [isDragging, setIsDragging] = useState(false);
   const [isGenerating, setIsGenerating] = useState(false);
+  const [contentWarnings, setContentWarnings] = useState<ContentValidationResponse | null>(null);
+  const [showWarnings, setShowWarnings] = useState(false);
   
   // Generation mode selection
   const [generationMode, setGenerationMode] = useState<GenerationMode>(draft?.generationMode || 'frame-continuity');
-  
-  // Retry editing state
-  const [retryDialogue, setRetryDialogue] = useState('');
-  const [retryEnvironment, setRetryEnvironment] = useState('');
-  const [retryAction, setRetryAction] = useState('');
-  
-  // Initialize retry fields when error occurs
-  useEffect(() => {
-    if (retryState && segments[retryState.failedSegmentIndex]) {
-      const seg = segments[retryState.failedSegmentIndex];
-      setRetryDialogue(seg.action_timeline?.dialogue || '');
-      setRetryEnvironment(seg.scene_continuity?.environment || '');
-      setRetryAction(seg.character_description?.current_state || '');
-    }
-  }, [retryState, segments]);
-  
-  const handleRetrySubmit = () => {
-    if (!retryState) return;
-    
-    const idx = retryState.failedSegmentIndex;
-    const updatedSegments = [...segments];
-    
-    // Update the segment with edited values
-    if (updatedSegments[idx]) {
-      updatedSegments[idx] = {
-        ...updatedSegments[idx],
-        action_timeline: {
-          ...updatedSegments[idx].action_timeline,
-          dialogue: retryDialogue
-        },
-        scene_continuity: {
-          ...updatedSegments[idx].scene_continuity,
-          environment: retryEnvironment
-        },
-        character_description: {
-          ...updatedSegments[idx].character_description,
-          current_state: retryAction
-        }
-      };
-      
-      updateSegments(updatedSegments);
-    }
-    
-    // Clear error and resume
-    setRetryState(null);
-    setStep('generating_video');
-    setIsGenerating(true);
-    
-    // Resume generation based on provider
-    if (provider === 'kling') {
-        if (generationMode === 'frame-continuity') {
-            handleKlingFrameContinuityFlow();
-        } else {
-            handleKlingExtendFlow();
-        }
-    } else {
-        handleReplicateGeneration();
-    }
-  };
 
-  const handleCancelRetry = () => {
-    setRetryState(null);
-    setIsGenerating(false);
-  };
+  // Segment mode: fixed duration (4/6/8s) or AI decides per segment
+  const [segmentMode, setSegmentMode] = useState<'fixed' | 'ai_driven'>(draft?.segmentMode ?? 'fixed');
+  const [secondsPerSegment, setSecondsPerSegment] = useState<4 | 6 | 8>(draft?.secondsPerSegment ?? 8);
 
   // Show notification if draft was restored
   useEffect(() => {
@@ -168,15 +123,32 @@ export const GenerationForm: React.FC<GenerationFormProps> = ({ provider, onBack
     try {
       const draft = {
         formState,
-        imagePreview,
         generationMode,
+        segmentMode,
+        secondsPerSegment,
         savedAt: new Date().toISOString(),
       };
       localStorage.setItem(draftKey, JSON.stringify(draft));
     } catch (error) {
-      console.warn('Failed to save draft:', error);
+      if (error instanceof DOMException && error.name === 'QuotaExceededError') {
+        try {
+          localStorage.removeItem(draftKey);
+          const fallback = {
+            formState: { ...formState, script: formState.script.slice(0, 5000) },
+            generationMode,
+            segmentMode,
+            secondsPerSegment,
+            savedAt: new Date().toISOString(),
+          };
+          localStorage.setItem(draftKey, JSON.stringify(fallback));
+        } catch {
+          console.warn('Failed to save draft: quota exceeded');
+        }
+      } else {
+        console.warn('Failed to save draft:', error);
+      }
     }
-  }, [formState, imagePreview, generationMode, draftKey]);
+  }, [formState, imagePreview, generationMode, segmentMode, secondsPerSegment, draftKey]);
   
   // Clear draft function
   const clearDraft = useCallback(() => {
@@ -189,10 +161,44 @@ export const GenerationForm: React.FC<GenerationFormProps> = ({ provider, onBack
     }
   }, [draftKey]);
 
+  // Accumulate streamed segments so we can show them live and pass to context
+  const streamedSegmentsRef = useRef<VeoSegment[]>([]);
+
   // Calculate estimated segments
   const wordCount = formState.script.trim().split(/\s+/).filter(w => w).length;
   const estimatedSegments = wordCount > 0 ? Math.max(1, Math.min(Math.ceil(wordCount / 17), 10)) : 0;
 
+  // Validate content when script changes (debounced)
+  const validateScriptContent = useCallback(async (script: string) => {
+    if (!script.trim() || isReuseMode) {
+      setContentWarnings(null);
+      return;
+    }
+
+    try {
+      const validation = await validateContent(script);
+      if (!validation.is_valid) {
+        setContentWarnings(validation);
+        setShowWarnings(true);
+      } else {
+        setContentWarnings(null);
+        setShowWarnings(false);
+      }
+    } catch (error) {
+      console.error('Content validation error:', error);
+      // Silently fail - don't block user
+    }
+  }, [isReuseMode]);
+
+  // Debounce content validation
+  useEffect(() => {
+    const timer = setTimeout(() => {
+      validateScriptContent(formState.script);
+    }, 1000); // Validate 1 second after user stops typing
+
+    return () => clearTimeout(timer);
+  }, [formState.script, validateScriptContent]);
+
   // Handle input changes
   const handleChange = (e: React.ChangeEvent<HTMLInputElement | HTMLTextAreaElement | HTMLSelectElement>) => {
     const { name, value } = e.target;
@@ -283,56 +289,131 @@ export const GenerationForm: React.FC<GenerationFormProps> = ({ provider, onBack
   // 3. Use that frame as reference for next segment
   // 4. Repeat for all segments
   
-  const handleKlingFrameContinuityFlow = async () => {
-    if (!imageFile || !formState.script.trim()) return;
+  const handleKlingFrameContinuityFlow = async (attemptCount: number = 0) => {
+    if (!imageFile) return;
+    if (!isReuseMode && !formState.script.trim()) return;
 
     setIsGenerating(true);
     setError(null);
-
+    
+    let segmentsToUse: VeoSegment[] = [];
+    let currentImageFile = imageFile; // Declare at function scope for catch block access
+    
     try {
-      // Step 1: Generate prompts using GPT-4o
-      updateProgress('Analyzing script with GPT-4o...');
       
-      const formData = new FormData();
-      formData.append('script', formState.script);
-      formData.append('style', formState.style || 'clean, lifestyle UGC');
-      formData.append('jsonFormat', 'standard');
-      formData.append('continuationMode', 'true');
-      formData.append('voiceType', formState.voiceType || '');
-      formData.append('energyLevel', formState.energyLevel || '');
-      formData.append('settingMode', 'single');
-      formData.append('cameraStyle', formState.cameraStyle || '');
-      formData.append('narrativeStyle', formState.narrativeStyle || '');
-      formData.append('image', imageFile);
-
-      const payload = await generatePrompts(formData);
-
-      if (!payload?.segments?.length) {
-        throw new Error('No segments generated from script');
-      }
+      // Step 1: Get segments - either from cache (reuse mode), existing segments (retry mode), or generate new ones
+      if ((isReuseMode || attemptCount > 0) && segments.length > 0) {
+        // REUSE MODE or RETRY MODE: Skip prompt generation, use existing segments
+        const mode = isReuseMode ? 'REUSE' : 'RETRY';
+        console.log(`♻️ ${mode} MODE: Using ${segments.length} existing segments (attempt ${attemptCount})`);
+        segmentsToUse = segments;
+        setStep('generating_video');
+        updateProgress(`Starting video generation with ${segments.length} ${mode === 'RETRY' ? 'cached' : 'pre-loaded'} segments...`, 0, segments.length);
+      } else {
+        // NORMAL MODE: Generate prompts using GPT-5.2 with STREAMING
+        setStep('generating_prompts');
+        updateProgress('🌊 Streaming prompt generation with GPT-5.2...', 0, estimatedSegments);
+        
+        const formData = new FormData();
+        formData.append('script', formState.script);
+        formData.append('style', formState.style || 'clean, lifestyle UGC');
+        formData.append('jsonFormat', 'standard');
+        formData.append('continuationMode', 'true');
+        formData.append('voiceType', formState.voiceType || '');
+        formData.append('energyLevel', formState.energyLevel || '');
+        formData.append('settingMode', 'single');
+        formData.append('cameraStyle', formState.cameraStyle || '');
+        formData.append('narrativeStyle', formState.narrativeStyle || '');
+        formData.append('image', imageFile);
+        formData.append('segment_mode', segmentMode);
+        formData.append('seconds_per_segment', String(secondsPerSegment));
+        if (segmentMode === 'ai_driven') formData.append('allowed_durations', '4,6,8');
 
-      const segments = payload.segments;
-      updateProgress(`Generated ${segments.length} segments. Starting video generation...`);
-      startGeneration(segments);
+        streamedSegmentsRef.current = [];
+        const promptAbort = new AbortController();
+        registerPromptAbortController(promptAbort);
+        try {
+          const payload = await generatePromptsStreaming(
+            formData,
+            (event: StreamEvent) => {
+              switch (event.event) {
+                case 'start':
+                  streamedSegmentsRef.current = [];
+                  updateSegments([]);
+                  console.log(`🌊 Starting streaming generation of ${event.total_segments} segments`);
+                  updateProgress(`Streaming ${event.total_segments} segments from GPT-5.2...`, 0, event.total_segments);
+                  break;
+
+                case 'segment': {
+                  const seg = (event as StreamSegmentEvent).segment;
+                  if (seg) {
+                    streamedSegmentsRef.current = [...streamedSegmentsRef.current, seg];
+                    updateSegments(streamedSegmentsRef.current);
+                  }
+                  console.log(`✅ Segment ${event.index + 1} complete (${event.progress.toFixed(1)}%)`);
+                  updateProgress(`Generated segment ${event.index + 1}... (${event.progress.toFixed(1)}%)`);
+                  break;
+                }
+
+                case 'complete':
+                  console.log(`🎉 All ${event.payload.segments.length} segments generated!`);
+                  updateProgress('All segments generated! Starting video generation...');
+                  break;
+
+                case 'error':
+                  console.error(`❌ Streaming error: ${event.message}`);
+                  throw new Error(event.message);
+              }
+            },
+            { signal: promptAbort.signal }
+          );
+
+          if (!payload?.segments?.length) {
+            throw new Error('No segments generated from script');
+          }
+
+          segmentsToUse = payload.segments;
+          updateProgress(`Generated ${segmentsToUse.length} segments. Starting video generation...`);
+          startGeneration(segmentsToUse);
+        } finally {
+          registerPromptAbortController(null);
+        }
+      }
 
       // Track current reference image (starts with original)
       let currentImageFile = imageFile;
-      const generatedVideos: GeneratedVideo[] = [];
+      
+      // RESUME SUPPORT: Start from where we left off if retrying
+      const startIndex = attemptCount > 0 ? generatedVideos.length : 0;
+      
+      // If resuming, extract last frame from previous video for continuity
+      if (startIndex > 0 && generatedVideos[startIndex - 1]?.blobUrl) {
+        updateProgress(`Resuming from segment ${startIndex + 1}...`);
+        console.log(`🔄 Resuming generation from segment ${startIndex + 1} (${generatedVideos.length} videos already generated)`);
+        try {
+          const lastVideoBlob = await fetch(generatedVideos[startIndex - 1].blobUrl!).then(r => r.blob());
+          const lastFrameFile = await extractLastFrame(lastVideoBlob);
+          currentImageFile = lastFrameFile;
+          console.log(`✅ Using frame from segment ${startIndex} for continuity`);
+        } catch (frameError) {
+          console.warn('⚠️ Failed to extract frame for resume, using original image:', frameError);
+        }
+      }
 
       // Step 2: Generate videos segment by segment with frame continuity
-      for (let i = 0; i < segments.length; i++) {
-        const segment = segments[i];
-        const isLastSegment = i === segments.length - 1;
+      for (let i = startIndex; i < segmentsToUse.length; i++) {
+        const segment = segmentsToUse[i];
+        const isLastSegment = i === segmentsToUse.length - 1;
         
         updateProgress(
-          `Generating video ${i + 1} of ${segments.length}...${i > 0 ? ' (using last frame from previous)' : ''}`, 
+          `Generating video ${i + 1} of ${segmentsToUse.length}...${i > 0 ? ' (using last frame from previous)' : ''}`, 
           i, 
-          segments.length
+          segmentsToUse.length
         );
 
         // Upload current reference image
         updateProgress(`Uploading reference image for segment ${i + 1}...`);
-        const uploadResult = await uploadImage(currentImageFile);
+        const uploadResult = await uploadImage(currentImageFile, { reference: true });
         const hostedImageUrl = uploadResult.url;
 
         console.log(`🖼️ Segment ${i + 1} using image: ${i === 0 ? 'original' : 'last frame from previous'}`);
@@ -381,16 +462,19 @@ export const GenerationForm: React.FC<GenerationFormProps> = ({ provider, onBack
             });
             
             if (whisperResult.success && whisperResult.frame_base64) {
-              // Convert base64 frame to File for next segment
-              const base64Data = whisperResult.frame_base64.split(',')[1] || whisperResult.frame_base64;
+              // Convert base64 frame to File for next segment (backend may return PNG or JPEG)
+              const dataUrl = whisperResult.frame_base64;
+              const mime = dataUrl.startsWith('data:image/png') ? 'image/png' : 'image/jpeg';
+              const ext = mime === 'image/png' ? 'png' : 'jpg';
+              const base64Data = dataUrl.split(',')[1] || dataUrl;
               const byteCharacters = atob(base64Data);
               const byteNumbers = new Array(byteCharacters.length);
               for (let j = 0; j < byteCharacters.length; j++) {
                 byteNumbers[j] = byteCharacters.charCodeAt(j);
               }
               const byteArray = new Uint8Array(byteNumbers);
-              const frameBlob = new Blob([byteArray], { type: 'image/jpeg' });
-              currentImageFile = new File([frameBlob], `whisper-frame-${i + 1}.jpg`, { type: 'image/jpeg' });
+              const frameBlob = new Blob([byteArray], { type: mime });
+              currentImageFile = new File([frameBlob], `whisper-frame-${i + 1}.${ext}`, { type: mime });
               
               // Store trim point for later merge
               if (whisperResult.trim_point) {
@@ -406,7 +490,7 @@ export const GenerationForm: React.FC<GenerationFormProps> = ({ provider, onBack
               console.log(`✅ Whisper: Last word at ${whisperResult.last_word_timestamp?.toFixed(2)}s, frame at ${whisperResult.frame_timestamp?.toFixed(2)}s, trim at ${trimPoint.toFixed(2)}s`);
               
               // REFINE NEXT SEGMENT PROMPT with frame + transcription
-              const nextSegment = segments[i + 1];
+              const nextSegment = segmentsToUse[i + 1];
               if (nextSegment && currentImageFile) {
                 updateProgress(`Refining segment ${i + 2} prompt with visual and audio context...`);
                 try {
@@ -418,7 +502,7 @@ export const GenerationForm: React.FC<GenerationFormProps> = ({ provider, onBack
                     dialogue
                   );
                   // Update the next segment with refined prompt
-                  segments[i + 1] = refined.refined_prompt as typeof nextSegment;
+                  segmentsToUse[i + 1] = refined.refined_prompt as typeof nextSegment;
                   console.log(`✅ Refined segment ${i + 2} prompt for consistency`);
                 } catch (refineError) {
                   console.warn(`⚠️ Prompt refinement failed, using original:`, refineError);
@@ -451,10 +535,9 @@ export const GenerationForm: React.FC<GenerationFormProps> = ({ provider, onBack
           thumbnails,
           trimPoint, // Store trim point for merge
         };
-        generatedVideos.push(generatedVideo);
         addVideo(generatedVideo);
 
-        updateProgress(`Completed video ${i + 1} of ${segments.length}`, i + 1, segments.length);
+        updateProgress(`Completed video ${i + 1} of ${segmentsToUse.length}`, i + 1, segmentsToUse.length);
       }
 
       // All done!
@@ -466,13 +549,320 @@ export const GenerationForm: React.FC<GenerationFormProps> = ({ provider, onBack
     } catch (err) {
       console.error('Generation error:', err);
       const errorMessage = err instanceof Error ? err.message : 'Generation failed';
+      const isUserCancel = (err as Error & { name?: string })?.name === 'AbortError' || errorMessage.includes('cancelled') || isCancelling;
+
+      // If user cancelled, context already set error with segment/video count; don't overwrite
+      if (isUserCancel) {
+        setStep('error');
+        setIsGenerating(false);
+        return;
+      }
+
+      {
+      // Check if this is a safety error that can be auto-fixed
+      if (isUnsafeSegmentError(errorMessage) && attemptCount < AUTO_FIX_MAX_ATTEMPTS) {
+        const segmentIndex = generatedVideos.length;
+        console.log(`🛡️ Safety error detected for segment ${segmentIndex + 1}, attempting auto-fix...`);
+        updateProgress(`Detected safety issue in segment ${segmentIndex + 1}, auto-fixing...`);
+        
+        try {
+          // Call AI to fix the unsafe segment
+          const fixResult = await fixUnsafePrompt({
+            segment: segmentsToUse[segmentIndex],
+            error_message: errorMessage,
+            attempt_count: attemptCount
+          });
+          
+          if (fixResult.success && fixResult.fixed_segment) {
+            console.log(`✅ Auto-fix successful: ${fixResult.changes_made}`);
+            updateProgress(`Fixed segment ${segmentIndex + 1}: ${fixResult.changes_made}`);
+            
+            // Update the segment with the fixed version IN THE LOCAL ARRAY
+            segmentsToUse[segmentIndex] = fixResult.fixed_segment;
+            
+            // Update context state (async, but we don't wait for it)
+            updateSegments(segmentsToUse);
+            
+            // IMPORTANT: Continue generating from current position with fixed segment
+            // Don't restart the whole function - just continue from current index
+            console.log(`🔄 Retrying segment ${segmentIndex + 1} with fixed prompt...`);
+            await new Promise(resolve => setTimeout(resolve, 1000));
+            
+            // Continue the loop from current segment (i stays the same, so it will retry)
+            // We do this by NOT incrementing i and continuing
+            // Actually, we're in the catch block, so we need to resume the generation
+            // The best approach is to just retry the current segment inline
+            
+            // Reset to retry current segment
+            updateProgress(`Retrying segment ${segmentIndex + 1} with fixed content...`, segmentIndex, segmentsToUse.length);
+            
+            // Re-run the segment generation with fixed prompt
+            const segment = segmentsToUse[segmentIndex];
+            const isLastSegment = segmentIndex === segmentsToUse.length - 1;
+            
+            // Upload current reference image (should still be set from before)
+            updateProgress(`Uploading reference image for segment ${segmentIndex + 1}...`);
+            const uploadResult = await uploadImage(currentImageFile, { reference: true });
+            const hostedImageUrl = uploadResult.url;
+
+            // Generate video with fixed prompt
+            updateProgress(`Submitting FIXED segment ${segmentIndex + 1} to KIE Veo 3.1...`);
+            const generateResult = await klingGenerate({
+              prompt: segment,
+              imageUrls: [hostedImageUrl],
+              model: 'veo3_fast',
+              aspectRatio: formState.aspectRatio,
+              generationType: 'FIRST_AND_LAST_FRAMES_2_VIDEO',
+              seeds: formState.seedValue,
+              voiceType: formState.voiceType,
+            });
+
+            // Wait for completion
+            updateProgress(`Processing FIXED video ${segmentIndex + 1}... (this may take 1-2 minutes)`);
+            const videoUrl = await waitForKlingVideo(generateResult.taskId);
+
+            // Download video
+            updateProgress(`Downloading video ${segmentIndex + 1}...`);
+            const videoBlob = await downloadVideo(videoUrl);
+            const blobUrl = URL.createObjectURL(videoBlob);
+
+            // Get video duration
+            const videoFile = new File([videoBlob], `segment-${segmentIndex + 1}.mp4`, { type: 'video/mp4' });
+            const duration = await getVideoDuration(videoFile);
+            const thumbnails = await generateThumbnails(videoFile);
+
+            // Extract frame for next segment if not last
+            let trimPoint = duration;
+            if (!isLastSegment) {
+              updateProgress(`Analyzing video ${segmentIndex + 1} with Whisper...`);
+              try {
+                const dialogue = segment.action_timeline?.dialogue || '';
+                const whisperResult = await whisperAnalyzeAndExtract({
+                  video_url: videoUrl,
+                  dialogue: dialogue,
+                  buffer_time: 0.3,
+                  model_size: 'base'
+                });
+                
+                if (whisperResult.success && whisperResult.frame_base64) {
+                  const dataUrl = whisperResult.frame_base64;
+                  const mime = dataUrl.startsWith('data:image/png') ? 'image/png' : 'image/jpeg';
+                  const ext = mime === 'image/png' ? 'png' : 'jpg';
+                  const base64Data = dataUrl.split(',')[1] || dataUrl;
+                  const byteCharacters = atob(base64Data);
+                  const byteNumbers = new Array(byteCharacters.length);
+                  for (let j = 0; j < byteCharacters.length; j++) {
+                    byteNumbers[j] = byteCharacters.charCodeAt(j);
+                  }
+                  const byteArray = new Uint8Array(byteNumbers);
+                  const frameBlob = new Blob([byteArray], { type: mime });
+                  currentImageFile = new File([frameBlob], `whisper-frame-${segmentIndex + 1}.${ext}`, { type: mime });
+                  
+                  if (whisperResult.trim_point) {
+                    trimPoint = whisperResult.trim_point;
+                  }
+                  const transcribedText = whisperResult.transcribed_text || '';
+                  const nextSegment = segmentsToUse[segmentIndex + 1];
+                  if (nextSegment && currentImageFile && transcribedText) {
+                    updateProgress(`Refining segment ${segmentIndex + 2} prompt with visual and audio context...`);
+                    try {
+                      const { refinePromptWithContext } = await import('@/utils/api');
+                      const refined = await refinePromptWithContext(
+                        nextSegment,
+                        currentImageFile,
+                        transcribedText,
+                        dialogue
+                      );
+                      segmentsToUse[segmentIndex + 1] = refined.refined_prompt as typeof nextSegment;
+                      console.log(`✅ Refined segment ${segmentIndex + 2} prompt for consistency`);
+                    } catch (refineError) {
+                      console.warn(`⚠️ Prompt refinement failed, using original:`, refineError);
+                    }
+                  }
+                }
+              } catch {
+                const lastFrameFile = await extractLastFrame(videoBlob);
+                currentImageFile = lastFrameFile;
+              }
+            }
+
+            // Add to generated videos
+            const generatedVideo: GeneratedVideo = {
+              id: `video-${Date.now()}-${segmentIndex}`,
+              url: videoUrl,
+              blobUrl,
+              segment,
+              duration,
+              thumbnails,
+              trimPoint,
+            };
+            addVideo(generatedVideo);
+
+            updateProgress(`Completed FIXED video ${segmentIndex + 1} of ${segmentsToUse.length}`, segmentIndex + 1, segmentsToUse.length);
+            
+            // Continue with remaining segments (DON'T restart the whole function!)
+            for (let i = segmentIndex + 1; i < segmentsToUse.length; i++) {
+              const segment = segmentsToUse[i];
+              const isLastSegment = i === segmentsToUse.length - 1;
+              
+              updateProgress(
+                `Generating video ${i + 1} of ${segmentsToUse.length}...${i > 0 ? ' (using last frame from previous)' : ''}`, 
+                i, 
+                segmentsToUse.length
+              );
+
+              // Upload current reference image
+              updateProgress(`Uploading reference image for segment ${i + 1}...`);
+              const uploadResult = await uploadImage(currentImageFile, { reference: true });
+              const hostedImageUrl = uploadResult.url;
+
+              console.log(`🖼️ Segment ${i + 1} using image: ${i === 0 ? 'original' : 'last frame from previous'}`);
+
+              // Generate video with current reference image
+              updateProgress(`Submitting segment ${i + 1} to KIE Veo 3.1...`);
+              const generateResult = await klingGenerate({
+                prompt: segment,
+                imageUrls: [hostedImageUrl],
+                model: 'veo3_fast',
+                aspectRatio: formState.aspectRatio,
+                generationType: 'FIRST_AND_LAST_FRAMES_2_VIDEO',
+                seeds: formState.seedValue,
+                voiceType: formState.voiceType,
+              });
+
+              // Wait for completion
+              updateProgress(`Processing video ${i + 1}... (this may take 1-2 minutes)`);
+              const videoUrl = await waitForKlingVideo(generateResult.taskId);
+
+              // Download video
+              updateProgress(`Downloading video ${i + 1}...`);
+              const videoBlob = await downloadVideo(videoUrl);
+              const blobUrl = URL.createObjectURL(videoBlob);
+
+              // Get video duration
+              const videoFile = new File([videoBlob], `segment-${i + 1}.mp4`, { type: 'video/mp4' });
+              const duration = await getVideoDuration(videoFile);
+              const thumbnails = await generateThumbnails(videoFile);
+
+              // Use Whisper to find optimal trim point, extract frame, and get transcription
+              let trimPoint = duration;
+              let transcribedText = '';
+              
+              if (!isLastSegment) {
+                updateProgress(`Analyzing video ${i + 1} with Whisper for optimal continuity...`);
+                try {
+                  const dialogue = segment.action_timeline?.dialogue || '';
+                  
+                  const whisperResult = await whisperAnalyzeAndExtract({
+                    video_url: videoUrl,
+                    dialogue: dialogue,
+                    buffer_time: 0.3,
+                    model_size: 'base'
+                  });
+                  
+                  if (whisperResult.success && whisperResult.frame_base64) {
+                    const dataUrl = whisperResult.frame_base64;
+                    const mime = dataUrl.startsWith('data:image/png') ? 'image/png' : 'image/jpeg';
+                    const ext = mime === 'image/png' ? 'png' : 'jpg';
+                    const base64Data = dataUrl.split(',')[1] || dataUrl;
+                    const byteCharacters = atob(base64Data);
+                    const byteNumbers = new Array(byteCharacters.length);
+                    for (let j = 0; j < byteCharacters.length; j++) {
+                      byteNumbers[j] = byteCharacters.charCodeAt(j);
+                    }
+                    const byteArray = new Uint8Array(byteNumbers);
+                    const frameBlob = new Blob([byteArray], { type: mime });
+                    currentImageFile = new File([frameBlob], `whisper-frame-${i + 1}.${ext}`, { type: mime });
+                    
+                    if (whisperResult.trim_point) {
+                      trimPoint = whisperResult.trim_point;
+                    }
+                    
+                    if (whisperResult.transcribed_text) {
+                      transcribedText = whisperResult.transcribed_text;
+                      console.log(`📝 Whisper transcription: "${transcribedText.substring(0, 100)}..."`);
+                    }
+                    
+                    console.log(`✅ Whisper: Last word at ${whisperResult.last_word_timestamp?.toFixed(2)}s, frame at ${whisperResult.frame_timestamp?.toFixed(2)}s, trim at ${trimPoint.toFixed(2)}s`);
+                    
+                    // REFINE NEXT SEGMENT PROMPT with frame + transcription
+                    const nextSegment = segmentsToUse[i + 1];
+                    if (nextSegment && currentImageFile) {
+                      updateProgress(`Refining segment ${i + 2} prompt with visual and audio context...`);
+                      try {
+                        const { refinePromptWithContext } = await import('@/utils/api');
+                        const refined = await refinePromptWithContext(
+                          nextSegment,
+                          currentImageFile,
+                          transcribedText,
+                          dialogue
+                        );
+                        segmentsToUse[i + 1] = refined.refined_prompt as typeof nextSegment;
+                        console.log(`✅ Refined segment ${i + 2} prompt for consistency`);
+                      } catch (refineError) {
+                        console.warn(`⚠️ Prompt refinement failed, using original:`, refineError);
+                      }
+                    }
+                  } else {
+                    console.log(`⚠️ Whisper failed (${whisperResult.error}), falling back to last frame extraction`);
+                    const lastFrameFile = await extractLastFrame(videoBlob);
+                    currentImageFile = lastFrameFile;
+                  }
+                } catch (frameError) {
+                  console.error(`⚠️ Whisper analysis failed, using fallback:`, frameError);
+                  try {
+                    const lastFrameFile = await extractLastFrame(videoBlob);
+                    currentImageFile = lastFrameFile;
+                  } catch {
+                    // Continue with current image if all extraction fails
+                  }
+                }
+              }
+
+              // Add to generated videos with trim metadata
+              const generatedVideo: GeneratedVideo = {
+                id: `video-${Date.now()}-${i}`,
+                url: videoUrl,
+                blobUrl,
+                segment,
+                duration,
+                thumbnails,
+                trimPoint,
+              };
+              addVideo(generatedVideo);
+
+              updateProgress(`Completed video ${i + 1} of ${segmentsToUse.length}`, i + 1, segmentsToUse.length);
+            }
+            
+            // All done after fixing and continuing!
+            clearDraft();
+            setStep('completed');
+            updateProgress('All videos generated successfully!');
+            return; // Exit successfully - don't continue to normal retry logic
+          } else {
+            console.warn(`⚠️ Auto-fix failed: ${fixResult.error}, falling back to manual retry`);
+          }
+        } catch (fixError) {
+          console.error('❌ Auto-fix error:', fixError);
+        }
+      }
       
-      // Enable retry mode
-      setRetryState({
-        failedSegmentIndex: generatedVideos.length, // Current segment that failed
-        error: errorMessage
+      const outcome: FlowRetryOutcome = await handleFlowRetry({
+        attemptCount,
+        errorMessage,
+        isCancelled: false,
+        generatedCount: generatedVideos.length,
+        totalCount: segmentsToUse.length,
+        setError,
+        setStep,
+        setPartialCompletionError,
       });
-      setStep('configuring'); // Go back to form, but with retry overlay
+      if (outcome === 'retry') {
+        console.log('🔄 First attempt failed, auto-retrying...');
+        updateProgress('Generation failed, automatically retrying...');
+        return handleKlingFrameContinuityFlow(1);
+      }
+      }
       
     } finally {
       setIsGenerating(false);
@@ -484,42 +874,81 @@ export const GenerationForm: React.FC<GenerationFormProps> = ({ provider, onBack
   // ============================================
   // Original flow using KIE's extend API
   
-  const handleKlingExtendFlow = async () => {
+  const handleKlingExtendFlow = async (attemptCount: number = 0) => {
     if (!imageFile || !formState.script.trim()) return;
 
     setIsGenerating(true);
     setError(null);
+    
+    let payload: { segments: VeoSegment[] } = { segments: [] }; // Declare at function scope
 
     try {
-      // Step 1: Generate prompts using GPT-4o
-      updateProgress('Analyzing script with GPT-4o...');
-      
-      const formData = new FormData();
-      formData.append('script', formState.script);
-      formData.append('style', formState.style || 'clean, lifestyle UGC');
-      formData.append('jsonFormat', 'standard');
-      formData.append('continuationMode', 'true');
-      formData.append('voiceType', formState.voiceType || '');
-      formData.append('energyLevel', formState.energyLevel || '');
-      formData.append('settingMode', 'single');
-      formData.append('cameraStyle', formState.cameraStyle || '');
-      formData.append('narrativeStyle', formState.narrativeStyle || '');
-      formData.append('image', imageFile);
-
-      // Use existing segments if retrying, otherwise generate new ones
-      let payload: { segments: VeoSegment[] };
-      if (retryState && segments.length > 0) {
-        // Retry mode: use existing segments (they may have been edited)
+      // Step 1: Get segments - skip prompt generation if segments already exist (retry mode)
+      if (attemptCount > 0 && segments.length > 0) {
+        // RETRY MODE: Use existing segments (they may have been edited)
+        console.log(`♻️ RETRY MODE: Using ${segments.length} existing segments (attempt ${attemptCount})`);
         payload = { segments };
-        updateProgress(`Using existing ${segments.length} segments for retry...`);
+        setStep('generating_video');
+        updateProgress(`Retrying video generation with ${segments.length} cached segments...`, 0, segments.length);
       } else {
-        // Normal mode: generate new segments
-        payload = await generatePrompts(formData);
-        if (!payload?.segments?.length) {
-          throw new Error('No segments generated from script');
+        // NORMAL MODE: Generate prompts using streaming (GPT-5.2)
+        setStep('generating_prompts');
+        updateProgress('Streaming prompt generation with GPT-5.2...', 0, estimatedSegments);
+
+        const formData = new FormData();
+        formData.append('script', formState.script);
+        formData.append('style', formState.style || 'clean, lifestyle UGC');
+        formData.append('jsonFormat', 'standard');
+        formData.append('continuationMode', 'true');
+        formData.append('voiceType', formState.voiceType || '');
+        formData.append('energyLevel', formState.energyLevel || '');
+        formData.append('settingMode', 'single');
+        formData.append('cameraStyle', formState.cameraStyle || '');
+        formData.append('narrativeStyle', formState.narrativeStyle || '');
+        formData.append('image', imageFile);
+        formData.append('segment_mode', segmentMode);
+        formData.append('seconds_per_segment', String(secondsPerSegment));
+        if (segmentMode === 'ai_driven') formData.append('allowed_durations', '4,6,8');
+
+        streamedSegmentsRef.current = [];
+        const promptAbortExtend = new AbortController();
+        registerPromptAbortController(promptAbortExtend);
+        try {
+          payload = await generatePromptsStreaming(
+            formData,
+            (event: StreamEvent) => {
+              switch (event.event) {
+                case 'start':
+                  streamedSegmentsRef.current = [];
+                  updateSegments([]);
+                  updateProgress(`Streaming ${event.total_segments} segments from GPT-5.2...`, 0, event.total_segments);
+                  break;
+                case 'segment': {
+                  const seg = (event as StreamSegmentEvent).segment;
+                  if (seg) {
+                    streamedSegmentsRef.current = [...streamedSegmentsRef.current, seg];
+                    updateSegments(streamedSegmentsRef.current);
+                  }
+                  updateProgress(`Generated segment ${event.index + 1}... (${event.progress.toFixed(1)}%)`);
+                  break;
+                }
+                case 'complete':
+                  updateProgress('All segments generated! Starting video generation...');
+                  break;
+                case 'error':
+                  throw new Error(event.message);
+              }
+            },
+            { signal: promptAbortExtend.signal }
+          );
+          if (!payload?.segments?.length) {
+            throw new Error('No segments generated from script');
+          }
+          updateProgress(`Generated ${payload.segments.length} segments. Starting video generation...`);
+          startGeneration(payload.segments);
+        } finally {
+          registerPromptAbortController(null);
         }
-        updateProgress(`Generated ${payload.segments.length} segments. Starting video generation...`);
-        startGeneration(payload.segments);
       }
 
       // Step 2: Upload reference image once
@@ -538,7 +967,7 @@ export const GenerationForm: React.FC<GenerationFormProps> = ({ provider, onBack
         try {
           const lastVideoBlob = await fetch(generatedVideos[startIndex - 1].blobUrl!).then(r => r.blob());
           const lastFrameFile = await extractLastFrame(lastVideoBlob);
-          const frameUploadResult = await uploadImage(lastFrameFile);
+          const frameUploadResult = await uploadImage(lastFrameFile, { reference: true });
           currentImageUrl = frameUploadResult.url;
           updateProgress(`Using frame from segment ${startIndex} for segment ${startIndex + 1}...`);
         } catch (frameError) {
@@ -587,7 +1016,7 @@ export const GenerationForm: React.FC<GenerationFormProps> = ({ provider, onBack
             return extendResult;
           }
         }, 300000, (attempt) => {
-          updateProgress(`Retrying video ${i + 1}... (attempt ${attempt}/2)`);
+          updateProgress(`Retrying video ${i + 1}... (attempt ${attempt}/${MAX_VIDEO_ATTEMPTS})`);
         });
 
         // Download and save
@@ -623,20 +1052,21 @@ export const GenerationForm: React.FC<GenerationFormProps> = ({ provider, onBack
     } catch (err) {
       console.error('Generation error:', err);
       const errorMessage = err instanceof Error ? err.message : 'Generation failed';
-      
-      // If cancelled, don't show retry option
-      if (errorMessage.includes('cancelled') || isCancelling) {
-        setError('Generation cancelled by user');
-        setStep('error');
-      } else {
-        // Enable retry mode
-        setRetryState({
-          failedSegmentIndex: generatedVideos.length, // Current segment that failed
-          error: errorMessage
-        });
-        setStep('configuring'); // Go back to form, but with retry overlay
+      const outcome = await handleFlowRetry({
+        attemptCount,
+        errorMessage,
+        isCancelled: errorMessage.includes('cancelled') || isCancelling,
+        generatedCount: generatedVideos.length,
+        totalCount: payload.segments.length,
+        setError,
+        setStep,
+        setPartialCompletionError,
+      });
+      if (outcome === 'retry') {
+        console.log('🔄 First attempt failed, auto-retrying...');
+        updateProgress('Generation failed, automatically retrying...');
+        return handleKlingExtendFlow(1);
       }
-      
     } finally {
       setIsGenerating(false);
       // Clean up any remaining task IDs
@@ -648,67 +1078,112 @@ export const GenerationForm: React.FC<GenerationFormProps> = ({ provider, onBack
   // REPLICATE GENERATION - FRAME CONTINUITY FLOW
   // ============================================
   // This mirrors the approach from standalone_video_creator.py:
-  // 1. Generate prompts using GPT-4o
+  // 1. Generate prompts using streaming (GPT-5.2)
   // 2. For each segment, generate video with current reference image
   // 3. Extract last frame from generated video
   // 4. Use that frame as reference for next segment
   // 5. Result: Perfect visual continuity across all segments
   
-  const handleReplicateGeneration = async () => {
+  const handleReplicateGeneration = async (attemptCount: number = 0) => {
     if (!formState.script.trim()) return;
 
     setIsGenerating(true);
     setError(null);
+    
+    let segmentsToUse: VeoSegment[] = []; // Declare at function scope
 
     try {
-      // Step 1: Generate prompts using GPT-4o
-      // Note: Replicate can work without an image, but for consistency we encourage one
-      updateProgress('Analyzing script with GPT-4o...');
+      // Step 1: Get segments - skip prompt generation if segments already exist (retry mode)
       
-      const formData = new FormData();
-      formData.append('script', formState.script);
-      formData.append('style', formState.style || 'clean, lifestyle UGC');
-      formData.append('jsonFormat', 'standard');
-      formData.append('continuationMode', 'true');
-      formData.append('voiceType', formState.voiceType || '');
-      formData.append('energyLevel', formState.energyLevel || '');
-      formData.append('settingMode', 'single');
-      formData.append('cameraStyle', formState.cameraStyle || '');
-      formData.append('narrativeStyle', formState.narrativeStyle || '');
-      
-      // If image provided, include it for GPT-4o analysis
-      if (imageFile) {
-        formData.append('image', imageFile);
+      if (attemptCount > 0 && segments.length > 0) {
+        // RETRY MODE: Use existing segments
+        console.log(`♻️ RETRY MODE: Using ${segments.length} existing segments (attempt ${attemptCount})`);
+        segmentsToUse = segments;
+        setStep('generating_video');
+        updateProgress(`Retrying video generation with ${segments.length} cached segments...`, 0, segments.length);
       } else {
-        // Create a placeholder image for GPT-4o (it needs one for analysis)
-        // In production, you might want to handle this differently
-        const placeholderBlob = new Blob(['placeholder'], { type: 'image/jpeg' });
-        formData.append('image', placeholderBlob, 'placeholder.jpg');
-      }
+        // NORMAL MODE: Generate prompts using streaming (GPT-5.2)
+        setStep('generating_prompts');
+        updateProgress('Streaming prompt generation with GPT-5.2...', 0, estimatedSegments);
+
+        const formData = new FormData();
+        formData.append('script', formState.script);
+        formData.append('style', formState.style || 'clean, lifestyle UGC');
+        formData.append('jsonFormat', 'standard');
+        formData.append('continuationMode', 'true');
+        formData.append('voiceType', formState.voiceType || '');
+        formData.append('energyLevel', formState.energyLevel || '');
+        formData.append('settingMode', 'single');
+        formData.append('cameraStyle', formState.cameraStyle || '');
+        formData.append('narrativeStyle', formState.narrativeStyle || '');
+
+        // If image provided, include it for GPT analysis
+        if (imageFile) {
+          formData.append('image', imageFile);
+        } else {
+          const placeholderBlob = new Blob(['placeholder'], { type: 'image/jpeg' });
+          formData.append('image', placeholderBlob, 'placeholder.jpg');
+        }
+        formData.append('segment_mode', segmentMode);
+        formData.append('seconds_per_segment', String(secondsPerSegment));
+        if (segmentMode === 'ai_driven') formData.append('allowed_durations', '4,6,8');
+
+        streamedSegmentsRef.current = [];
+        const promptAbortReplicate = new AbortController();
+        registerPromptAbortController(promptAbortReplicate);
+        try {
+          const payload = await generatePromptsStreaming(
+            formData,
+            (event: StreamEvent) => {
+              switch (event.event) {
+                case 'start':
+                  streamedSegmentsRef.current = [];
+                  updateSegments([]);
+                  updateProgress(`Streaming ${event.total_segments} segments...`, 0, event.total_segments);
+                  break;
+                case 'segment': {
+                  const seg = (event as StreamSegmentEvent).segment;
+                  if (seg) {
+                    streamedSegmentsRef.current = [...streamedSegmentsRef.current, seg];
+                    updateSegments(streamedSegmentsRef.current);
+                  }
+                  updateProgress(`Generated segment ${event.index + 1}... (${event.progress.toFixed(1)}%)`);
+                  break;
+                }
+                case 'complete':
+                  updateProgress('All segments generated! Starting Replicate generation...');
+                  break;
+                case 'error':
+                  throw new Error(event.message);
+              }
+            },
+            { signal: promptAbortReplicate.signal }
+          );
 
-      const payload = await generatePrompts(formData);
+          if (!payload?.segments?.length) {
+            throw new Error('No segments generated from script');
+          }
 
-      if (!payload?.segments?.length) {
-        throw new Error('No segments generated from script');
+          segmentsToUse = payload.segments;
+          updateProgress(`Generated ${segmentsToUse.length} segments. Starting Replicate generation...`);
+          startGeneration(segmentsToUse);
+        } finally {
+          registerPromptAbortController(null);
+        }
       }
 
-      const segments = payload.segments;
-      updateProgress(`Generated ${segments.length} segments. Starting Replicate generation...`);
-      startGeneration(segments);
-
       // Track current reference image (starts with original if provided)
       let currentImageFile = imageFile;
-      const generatedVideos: GeneratedVideo[] = [];
 
       // Step 2: Generate videos segment by segment with frame continuity
-      for (let i = 0; i < segments.length; i++) {
-        const segment = segments[i];
-        const isLastSegment = i === segments.length - 1;
+      for (let i = 0; i < segmentsToUse.length; i++) {
+        const segment = segmentsToUse[i];
+        const isLastSegment = i === segmentsToUse.length - 1;
         
         updateProgress(
-          `Generating video ${i + 1} of ${segments.length} with Replicate...${i > 0 ? ' (using last frame)' : ''}`, 
+          `Generating video ${i + 1} of ${segmentsToUse.length} with Replicate...${i > 0 ? ' (using last frame)' : ''}`, 
           i, 
-          segments.length
+          segmentsToUse.length
         );
 
         // Convert structured segment to text prompt for Replicate
@@ -721,7 +1196,7 @@ export const GenerationForm: React.FC<GenerationFormProps> = ({ provider, onBack
         let imageUrl: string | undefined;
         if (currentImageFile) {
           updateProgress(`Uploading reference image for segment ${i + 1}...`);
-          const uploadResult = await uploadImage(currentImageFile);
+          const uploadResult = await uploadImage(currentImageFile, { reference: true });
           imageUrl = uploadResult.url;
           console.log(`🖼️ Segment ${i + 1} using image: ${i === 0 ? 'original' : 'last frame from previous'}`);
         }
@@ -768,16 +1243,19 @@ export const GenerationForm: React.FC<GenerationFormProps> = ({ provider, onBack
             });
             
             if (whisperResult.success && whisperResult.frame_base64) {
-              // Convert base64 frame to File for next segment
-              const base64Data = whisperResult.frame_base64.split(',')[1] || whisperResult.frame_base64;
+              // Convert base64 frame to File for next segment (backend may return PNG or JPEG)
+              const dataUrl = whisperResult.frame_base64;
+              const mime = dataUrl.startsWith('data:image/png') ? 'image/png' : 'image/jpeg';
+              const ext = mime === 'image/png' ? 'png' : 'jpg';
+              const base64Data = dataUrl.split(',')[1] || dataUrl;
               const byteCharacters = atob(base64Data);
               const byteNumbers = new Array(byteCharacters.length);
               for (let j = 0; j < byteCharacters.length; j++) {
                 byteNumbers[j] = byteCharacters.charCodeAt(j);
               }
               const byteArray = new Uint8Array(byteNumbers);
-              const frameBlob = new Blob([byteArray], { type: 'image/jpeg' });
-              currentImageFile = new File([frameBlob], `whisper-frame-${i + 1}.jpg`, { type: 'image/jpeg' });
+              const frameBlob = new Blob([byteArray], { type: mime });
+              currentImageFile = new File([frameBlob], `whisper-frame-${i + 1}.${ext}`, { type: mime });
               
               // Store trim point for later merge
               if (whisperResult.trim_point) {
@@ -793,7 +1271,7 @@ export const GenerationForm: React.FC<GenerationFormProps> = ({ provider, onBack
               console.log(`✅ Whisper: Last word at ${whisperResult.last_word_timestamp?.toFixed(2)}s, frame at ${whisperResult.frame_timestamp?.toFixed(2)}s, trim at ${trimPoint.toFixed(2)}s`);
               
               // REFINE NEXT SEGMENT PROMPT with frame + transcription
-              const nextSegment = segments[i + 1];
+              const nextSegment = segmentsToUse[i + 1];
               if (nextSegment && currentImageFile) {
                 updateProgress(`Refining segment ${i + 2} prompt with visual and audio context...`);
                 try {
@@ -805,7 +1283,7 @@ export const GenerationForm: React.FC<GenerationFormProps> = ({ provider, onBack
                     dialogue
                   );
                   // Update the next segment with refined prompt
-                  segments[i + 1] = refined.refined_prompt as typeof nextSegment;
+                  segmentsToUse[i + 1] = refined.refined_prompt as typeof nextSegment;
                   console.log(`✅ Refined segment ${i + 2} prompt for consistency`);
                 } catch (refineError) {
                   console.warn(`⚠️ Prompt refinement failed, using original:`, refineError);
@@ -838,10 +1316,9 @@ export const GenerationForm: React.FC<GenerationFormProps> = ({ provider, onBack
           thumbnails,
           trimPoint, // Store trim point for merge
         };
-        generatedVideos.push(generatedVideo);
         addVideo(generatedVideo);
 
-        updateProgress(`Completed video ${i + 1} of ${segments.length}`, i + 1, segments.length);
+        updateProgress(`Completed video ${i + 1} of ${segmentsToUse.length}`, i + 1, segmentsToUse.length);
       }
 
       // All done!
@@ -851,14 +1328,21 @@ export const GenerationForm: React.FC<GenerationFormProps> = ({ provider, onBack
     } catch (err) {
       console.error('Replicate generation error:', err);
       const errorMessage = err instanceof Error ? err.message : 'Replicate generation failed';
-      
-      // Enable retry mode
-      setRetryState({
-        failedSegmentIndex: generatedVideos.length, // Current segment that failed
-        error: errorMessage
+      const outcome = await handleFlowRetry({
+        attemptCount,
+        errorMessage,
+        isCancelled: errorMessage.includes('cancelled') || isCancelling,
+        generatedCount: state.generatedVideos.length,
+        totalCount: segmentsToUse.length,
+        setError,
+        setStep,
+        setPartialCompletionError,
       });
-      setStep('configuring'); // Go back to form, but with retry overlay
-      
+      if (outcome === 'retry') {
+        console.log('🔄 First attempt failed, auto-retrying...');
+        updateProgress('Generation failed, automatically retrying...');
+        return handleReplicateGeneration(1);
+      }
     } finally {
       setIsGenerating(false);
     }
@@ -929,9 +1413,42 @@ export const GenerationForm: React.FC<GenerationFormProps> = ({ provider, onBack
     }
   };
 
+  // Handler for reuse mode - skip prompt generation, go directly to video generation
+  const handleReuseGeneration = (e: React.FormEvent) => {
+    e.preventDefault();
+    
+    if (!imageFile) {
+      alert('Please upload a character image to start video generation');
+      return;
+    }
+    
+    console.log(`🚀 Starting video generation with ${segments.length} pre-loaded segments (REUSE MODE)`);
+    
+    // Skip prompt generation entirely - go directly to video generation
+    if (provider === 'kling') {
+      if (generationMode === 'frame-continuity') {
+        // Start from the video generation part of the flow
+        setIsGenerating(true);
+        setError(null);
+        startGeneration(segments);
+        handleKlingFrameContinuityFlow(0);
+      } else {
+        setIsGenerating(true);
+        setError(null);
+        startGeneration(segments);
+        handleKlingExtendFlow(0);
+      }
+    } else {
+      setIsGenerating(true);
+      setError(null);
+      startGeneration(segments);
+      handleReplicateGeneration(0);
+    }
+  };
+
   const isValid = provider === 'kling' 
-    ? !!imageFile && formState.script.trim().length > 0
-    : formState.script.trim().length > 0;
+    ? !!imageFile && (isReuseMode || formState.script.trim().length > 0)
+    : (isReuseMode || formState.script.trim().length > 0);
 
   return (
     <motion.div
@@ -957,85 +1474,114 @@ export const GenerationForm: React.FC<GenerationFormProps> = ({ provider, onBack
             <span className="text-void-200"> Video Generation</span>
           </h1>
           <p className="text-void-400 mt-2">
-            {provider === 'kling' 
-              ? 'Generate professional UGC videos with AI-powered segmentation'
-              : 'Create unique videos with open-source models'
-            }
+            {isReuseMode ? (
+              <span className="flex items-center gap-2">
+                <span>♻️ Reusing {segments.length} cached segments - Upload image and click Generate to start</span>
+              </span>
+            ) : (
+              provider === 'kling' 
+                ? 'Generate professional UGC videos with AI-powered segmentation'
+                : 'Create unique videos with open-source models'
+            )}
           </p>
         </div>
       </div>
 
-      {/* Retry Modal */}
-      {retryState && (
-        <div className="fixed inset-0 z-50 flex items-center justify-center bg-black/80 backdrop-blur-sm p-4">
-          <motion.div 
-            initial={{ opacity: 0, scale: 0.95 }}
-            animate={{ opacity: 1, scale: 1 }}
-            className="bg-void-900 border border-void-700 rounded-2xl p-6 max-w-2xl w-full shadow-2xl overflow-y-auto max-h-[90vh]"
-          >
-            <div className="flex items-center gap-3 mb-4 text-red-400">
-              <svg className="w-6 h-6" fill="none" stroke="currentColor" viewBox="0 0 24 24">
-                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z" />
-              </svg>
-              <h3 className="text-xl font-bold">Generation Failed</h3>
-            </div>
-            
-            <p className="text-void-300 mb-6 p-4 bg-void-800 rounded-lg border border-void-700">
-              Error at segment {retryState.failedSegmentIndex + 1}: <span className="text-red-300">{retryState.error}</span>
-            </p>
-            
-            <div className="space-y-4 mb-8">
-              <h4 className="font-semibold text-void-200">Edit Segment {retryState.failedSegmentIndex + 1} to fix the issue:</h4>
-              
-              <div>
-                <label className="block text-sm font-medium text-void-400 mb-1">Dialogue</label>
-                <textarea
-                  value={retryDialogue}
-                  onChange={(e) => setRetryDialogue(e.target.value)}
-                  className="w-full bg-void-950 border border-void-700 rounded-lg p-3 text-void-100 h-24 focus:border-coral-500 focus:outline-none"
-                  placeholder="Adjust dialogue..."
-                />
-              </div>
-              
-              <div>
-                <label className="block text-sm font-medium text-void-400 mb-1">Action / Character State</label>
-                <textarea
-                  value={retryAction}
-                  onChange={(e) => setRetryAction(e.target.value)}
-                  className="w-full bg-void-950 border border-void-700 rounded-lg p-3 text-void-100 h-24 focus:border-coral-500 focus:outline-none"
-                  placeholder="Adjust action description..."
-                />
-              </div>
-
-              <div>
-                <label className="block text-sm font-medium text-void-400 mb-1">Environment</label>
-                <textarea
-                  value={retryEnvironment}
-                  onChange={(e) => setRetryEnvironment(e.target.value)}
-                  className="w-full bg-void-950 border border-void-700 rounded-lg p-3 text-void-100 h-24 focus:border-coral-500 focus:outline-none"
-                  placeholder="Adjust environment description..."
-                />
+      {/* Content Warnings */}
+      {contentWarnings && showWarnings && !isReuseMode && (
+        <motion.div
+          initial={{ opacity: 0, y: -10 }}
+          animate={{ opacity: 1, y: 0 }}
+          className="mb-6 p-4 bg-gradient-to-r from-amber-500/10 to-red-500/10 border-2 border-amber-500/30 rounded-xl"
+        >
+          <div className="flex items-start gap-3">
+            <span className="text-2xl">⚠️</span>
+            <div className="flex-1">
+              <h3 className="font-bold text-amber-400 mb-2">Content Policy Warnings</h3>
+              <div className="space-y-2 mb-3">
+                {contentWarnings.warnings.map((warning, idx) => (
+                  <p key={idx} className="text-sm text-void-300">{warning}</p>
+                ))}
               </div>
+              {contentWarnings.guidance && (
+                <details className="mt-3">
+                  <summary className="text-sm text-amber-300 cursor-pointer hover:text-amber-200">
+                    View Content Guidelines
+                  </summary>
+                  <div className="mt-2 space-y-2 text-xs text-void-400">
+                    <div>
+                      <strong className="text-void-300">Avoid Public Figures:</strong>
+                      <ul className="list-disc list-inside ml-2">
+                        {contentWarnings.guidance.avoid_public_figures.map((item, idx) => (
+                          <li key={idx}>{item}</li>
+                        ))}
+                      </ul>
+                    </div>
+                    <div>
+                      <strong className="text-void-300">Avoid Copyrighted Content:</strong>
+                      <ul className="list-disc list-inside ml-2">
+                        {contentWarnings.guidance.avoid_copyrighted.map((item, idx) => (
+                          <li key={idx}>{item}</li>
+                        ))}
+                      </ul>
+                    </div>
+                    <div>
+                      <strong className="text-void-300">Best Practices:</strong>
+                      <ul className="list-disc list-inside ml-2">
+                        {contentWarnings.guidance.best_practices.map((item, idx) => (
+                          <li key={idx}>{item}</li>
+                        ))}
+                      </ul>
+                    </div>
+                  </div>
+                </details>
+              )}
             </div>
-            
-            <div className="flex justify-end gap-3">
-              <button 
-                onClick={handleCancelRetry}
-                className="px-4 py-2 rounded-lg text-void-300 hover:text-white hover:bg-void-800 transition-colors"
-              >
-                Cancel
-              </button>
-              <button 
-                onClick={handleRetrySubmit}
-                className="px-6 py-2 bg-gradient-to-r from-coral-500 to-coral-600 text-white font-semibold rounded-lg hover:from-coral-400 hover:to-coral-500 shadow-lg shadow-coral-500/20"
-              >
-                Retry Generation
-              </button>
+            <button
+              onClick={() => setShowWarnings(false)}
+              className="text-void-400 hover:text-void-200 transition-colors"
+            >
+              <svg className="w-5 h-5" fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M6 18L18 6M6 6l12 12" />
+              </svg>
+            </button>
+          </div>
+        </motion.div>
+      )}
+
+      {/* Reuse Mode Banner */}
+      {isReuseMode && (
+        <motion.div
+          initial={{ opacity: 0, y: -10 }}
+          animate={{ opacity: 1, y: 0 }}
+          className="mb-6 p-4 bg-gradient-to-r from-green-500/10 to-blue-500/10 border-2 border-green-500/30 rounded-xl"
+        >
+          <div className="flex items-start gap-3">
+            <span className="text-2xl">♻️</span>
+            <div className="flex-1">
+              <h3 className="font-bold text-green-400 mb-1">Reusing Cached Prompts</h3>
+              <p className="text-sm text-void-300 mb-2">
+                {segments.length} segments are pre-loaded from your saved prompt. 
+                <strong className="text-green-400"> Prompt generation will be skipped.</strong>
+              </p>
+              <p className="text-xs text-void-400">
+                Simply upload your character image and click "Generate Video" to start creating videos immediately!
+              </p>
             </div>
-          </motion.div>
-        </div>
+            <button
+              onClick={() => {
+                updateSegments([]);
+                alert('Cleared cached segments. You can now enter a new script.');
+              }}
+              className="px-3 py-1 text-xs bg-void-800 hover:bg-void-700 text-void-300 rounded-lg transition-colors"
+            >
+              Clear & Start Fresh
+            </button>
+          </div>
+        </motion.div>
       )}
 
+
       {/* Draft Restored Notification */}
       {draftRestored && (
         <motion.div
@@ -1062,55 +1608,131 @@ export const GenerationForm: React.FC<GenerationFormProps> = ({ provider, onBack
         </motion.div>
       )}
 
-      <form onSubmit={handleSubmit}>
+      <form onSubmit={isReuseMode ? handleReuseGeneration : handleSubmit}>
         <div className="grid grid-cols-1 lg:grid-cols-2 gap-8">
           {/* Left Column - Script & Style */}
           <div className="space-y-6">
-            {/* Script Input */}
-            <div className="card">
-              <label className="block text-sm font-semibold text-void-200 mb-3">
-                Script <span className="text-coral-400">*</span>
-              </label>
-              <textarea
-                name="script"
-                value={formState.script}
-                onChange={handleChange}
-                rows={10}
-                className="textarea-field font-mono text-sm"
-                placeholder="Enter your complete video script here...
+            {/* Script Input - Hidden in reuse mode */}
+            {!isReuseMode && (
+              <div className="card">
+                <label className="block text-sm font-semibold text-void-200 mb-3">
+                  Script <span className="text-coral-400">*</span>
+                </label>
+                <textarea
+                  name="script"
+                  value={formState.script}
+                  onChange={handleChange}
+                  rows={10}
+                  className="textarea-field font-mono text-sm"
+                  placeholder="Enter your complete video script here...
 
 The AI will automatically analyze and segment your script into optimal video chunks, typically 8 seconds each."
-                required
-              />
-              <div className="flex items-center justify-between mt-3">
-                <p className="text-xs text-void-500">
-                  AI will automatically segment your script
+                  required={!isReuseMode}
+                />
+                <div className="flex items-center justify-between mt-3">
+                  <p className="text-xs text-void-500">
+                    AI will automatically segment your script
+                  </p>
+                  {wordCount > 0 && (
+                    <div className="flex items-center gap-4 text-xs">
+                      <span className="text-void-400">{wordCount} words</span>
+                      <span className={`font-semibold ${provider === 'kling' ? 'text-coral-400' : 'text-electric-400'}`}>
+                        ~{estimatedSegments} segments
+                      </span>
+                    </div>
+                  )}
+                </div>
+              </div>
+            )}
+
+            {/* Reuse Mode: Show segment count + same-image reminder */}
+            {isReuseMode && (
+              <div className="card border-2 border-green-500/30 bg-green-500/5">
+                <div className="flex items-center justify-between mb-3">
+                  <h4 className="text-sm font-semibold text-green-400">
+                    ✅ Segments Loaded from Cache
+                  </h4>
+                  <span className="px-3 py-1 bg-green-500/20 text-green-300 text-xs rounded-full font-bold">
+                    {segments.length} segments ready
+                  </span>
+                </div>
+                <p className="text-sm text-void-300 mb-2">
+                  Your cached prompts are loaded and ready for video generation.
+                </p>
+                <p className="text-xs text-amber-200/90 bg-amber-500/20 border border-amber-500/40 rounded-lg px-3 py-2 mb-2">
+                  ⚠️ Use the <strong>same reference image</strong> you used when creating this prompt for best visual continuity. The segment prompts describe that specific person and scene.
+                </p>
+                <p className="text-xs text-void-400">
+                  Estimated duration: ~{segments.length * 8} seconds
                 </p>
-                {wordCount > 0 && (
-                  <div className="flex items-center gap-4 text-xs">
-                    <span className="text-void-400">{wordCount} words</span>
-                    <span className={`font-semibold ${provider === 'kling' ? 'text-coral-400' : 'text-electric-400'}`}>
-                      ~{estimatedSegments} segments
-                    </span>
-                  </div>
-                )}
               </div>
-            </div>
+            )}
 
-            {/* Style Input */}
-            <div className="card">
-              <label className="block text-sm font-semibold text-void-200 mb-3">
-                Visual Style
-              </label>
-              <textarea
-                name="style"
-                value={formState.style}
-                onChange={handleChange}
-                rows={3}
-                className="textarea-field"
-                placeholder="e.g., Cinematic, hyper-realistic, natural lighting, modern aesthetic, warm tones..."
-              />
-            </div>
+            {/* Style Input - Hidden in reuse mode */}
+            {!isReuseMode && (
+              <div className="card">
+                <label className="block text-sm font-semibold text-void-200 mb-3">
+                  Visual Style
+                </label>
+                <textarea
+                  name="style"
+                  value={formState.style}
+                  onChange={handleChange}
+                  rows={3}
+                  className="textarea-field"
+                  placeholder="e.g., Cinematic, hyper-realistic, natural lighting, modern aesthetic, warm tones..."
+                />
+              </div>
+            )}
+
+            {/* Segment duration: fixed 4/6/8s or AI decides */}
+            {!isReuseMode && (
+              <div className="card border-2 border-void-500/30">
+                <label className="block text-sm font-semibold text-void-200 mb-3">
+                  Segment duration
+                </label>
+                <div className="space-y-3">
+                  <label className="flex items-center gap-3 cursor-pointer">
+                    <input
+                      type="radio"
+                      name="segmentMode"
+                      value="fixed"
+                      checked={segmentMode === 'fixed'}
+                      onChange={() => setSegmentMode('fixed')}
+                      className="w-4 h-4 accent-coral-500"
+                    />
+                    <span className="text-sm text-void-200">Fixed</span>
+                    <select
+                      value={secondsPerSegment}
+                      onChange={(e) => setSecondsPerSegment(Number(e.target.value) as 4 | 6 | 8)}
+                      disabled={segmentMode !== 'fixed'}
+                      className="ml-2 px-2 py-1 rounded bg-void-800 border border-void-600 text-void-200 text-sm"
+                    >
+                      <option value={4}>4 sec</option>
+                      <option value={6}>6 sec</option>
+                      <option value={8}>8 sec</option>
+                    </select>
+                    <span className="text-xs text-void-400">per segment</span>
+                  </label>
+                  <label className="flex items-start gap-3 cursor-pointer">
+                    <input
+                      type="radio"
+                      name="segmentMode"
+                      value="ai_driven"
+                      checked={segmentMode === 'ai_driven'}
+                      onChange={() => setSegmentMode('ai_driven')}
+                      className="mt-0.5 w-4 h-4 accent-coral-500"
+                    />
+                    <div>
+                      <span className="text-sm font-medium text-void-100">AI decides</span>
+                      <p className="text-xs text-void-400 mt-0.5">
+                        AI splits the script and chooses 4, 6, or 8 sec per segment for natural pacing.
+                      </p>
+                    </div>
+                  </label>
+                </div>
+              </div>
+            )}
 
             {/* Generation Mode Selection (Kling only) */}
             {provider === 'kling' && (
@@ -1164,8 +1786,8 @@ The AI will automatically analyze and segment your script into optimal video chu
               </div>
             )}
 
-            {/* Generation Preview */}
-            {estimatedSegments > 0 && (
+            {/* Generation Preview - Only show in normal mode */}
+            {!isReuseMode && estimatedSegments > 0 && (
               <motion.div 
                 initial={{ opacity: 0, scale: 0.95 }}
                 animate={{ opacity: 1, scale: 1 }}
@@ -1354,7 +1976,10 @@ The AI will automatically analyze and segment your script into optimal video chu
               className={`
                 w-full py-4 font-semibold rounded-xl transition-all duration-300
                 flex items-center justify-center gap-3
-                ${provider === 'kling' ? 'btn-primary' : 'btn-electric'}
+                ${isReuseMode 
+                  ? 'bg-gradient-to-r from-green-500 to-blue-500 hover:from-green-400 hover:to-blue-400 text-white shadow-lg shadow-green-500/30' 
+                  : provider === 'kling' ? 'btn-primary' : 'btn-electric'
+                }
                 disabled:opacity-50 disabled:cursor-not-allowed disabled:scale-100
               `}
             >
@@ -1363,6 +1988,13 @@ The AI will automatically analyze and segment your script into optimal video chu
                   <div className="w-5 h-5 border-2 border-white/30 border-t-white rounded-full animate-spin" />
                   <span>Generating...</span>
                 </>
+              ) : isReuseMode ? (
+                <>
+                  <span className="text-xl">🚀</span>
+                  <span>
+                    Start Video Generation ({segments.length} segments)
+                  </span>
+                </>
               ) : (
                 <>
                   <SparklesIcon size={20} />

frontend/src/components/GenerationProgress.tsx

@@ -1,6 +1,8 @@
 import React, { useState, useEffect, useRef } from 'react';
 import { motion, AnimatePresence } from 'framer-motion';
 import { useGeneration } from '@/context/GenerationContext';
+import { SegmentGenerationProgress } from './SegmentGenerationProgress';
+import { SegmentPromptsViewer } from './SegmentPromptsViewer';
 
 // Icons
 const CheckIcon = () => (
@@ -69,7 +71,25 @@ const XIcon = () => (
 
 export const GenerationProgress: React.FC = () => {
   const { state, cancelGeneration } = useGeneration();
-  const { progress, provider, generatedVideos, segments, isCancelling, activeTaskIds } = state;
+  const { progress, provider, generatedVideos, segments, isCancelling, activeTaskIds, step } = state;
+  
+  // Show enhanced UX during prompt generation (streaming)
+  // Use estimated count if segments not yet loaded, or actual count if available
+  if (step === 'generating_prompts') {
+    const estimatedCount = segments.length > 0 ? segments.length : (progress.total > 0 ? progress.total : 5);
+    const accentColor = provider === 'kling' ? 'coral' : 'electric';
+    return (
+      <div className="w-full max-w-4xl mx-auto space-y-8">
+        <SegmentGenerationProgress 
+          segmentsCount={Math.max(estimatedCount, segments.length)}
+          onCancel={cancelGeneration}
+        />
+        {segments.length > 0 && (
+          <SegmentPromptsViewer segments={segments} accentColor={accentColor} />
+        )}
+      </div>
+    );
+  }
   
   const [elapsedTime, setElapsedTime] = useState(0);
   const [activityLog, setActivityLog] = useState<ActivityLog[]>([]);
@@ -389,6 +409,21 @@ export const GenerationProgress: React.FC = () => {
           </div>
         </div>
 
+        {/* Segment Prompts Viewer - Show during video generation */}
+        {segments.length > 0 && (
+          <motion.div
+            initial={{ opacity: 0, y: 20 }}
+            animate={{ opacity: 1, y: 0 }}
+            transition={{ delay: 0.3 }}
+            className="mb-8"
+          >
+            <SegmentPromptsViewer 
+              segments={segments} 
+              accentColor={accentColor}
+            />
+          </motion.div>
+        )}
+
         {/* Bottom Progress Bar */}
         <div className="card p-4">
           <div className="flex items-center justify-between mb-2">

frontend/src/components/Icons.tsx

@@ -239,6 +239,55 @@ export const BrainIcon: React.FC<IconProps> = ({ className = '', size = 24 }) =>
   </svg>
 );
 
+export const ChevronDownIcon: React.FC<IconProps> = ({ className = '', size = 24 }) => (
+  <svg 
+    className={className} 
+    width={size} 
+    height={size} 
+    viewBox="0 0 24 24" 
+    fill="none" 
+    stroke="currentColor" 
+    strokeWidth="2" 
+    strokeLinecap="round" 
+    strokeLinejoin="round"
+  >
+    <polyline points="6 9 12 15 18 9" />
+  </svg>
+);
+
+export const ChevronUpIcon: React.FC<IconProps> = ({ className = '', size = 24 }) => (
+  <svg 
+    className={className} 
+    width={size} 
+    height={size} 
+    viewBox="0 0 24 24" 
+    fill="none" 
+    stroke="currentColor" 
+    strokeWidth="2" 
+    strokeLinecap="round" 
+    strokeLinejoin="round"
+  >
+    <polyline points="18 15 12 9 6 15" />
+  </svg>
+);
+
+export const CopyIcon: React.FC<IconProps> = ({ className = '', size = 24 }) => (
+  <svg 
+    className={className} 
+    width={size} 
+    height={size} 
+    viewBox="0 0 24 24" 
+    fill="none" 
+    stroke="currentColor" 
+    strokeWidth="2" 
+    strokeLinecap="round" 
+    strokeLinejoin="round"
+  >
+    <rect x="9" y="9" width="13" height="13" rx="2" ry="2" />
+    <path d="M5 15H4a2 2 0 01-2-2V4a2 2 0 012-2h9a2 2 0 012 2v1" />
+  </svg>
+);
+
 // Logo icon for the app
 export const LogoIcon: React.FC<IconProps> = ({ className = '', size = 40 }) => (
   <svg 

frontend/src/components/ProviderSelect.tsx

@@ -38,6 +38,16 @@ const providers: ProviderCard[] = [
       'Voice Type Selection',
     ],
     badge: 'Recommended',
+    pricing: {
+      per_second: 0.05,
+      samples: {
+        '1s': 0.05,
+        '8s': 0.4,
+        '30s': 1.5,
+        '60s': 3.0,
+      },
+      evidence: 'Veo 3 Fast (8s, with audio) — Kie.ai $0.40 (≈$0.05/sec)',
+    },
   },
   {
     id: 'replicate' as VideoProvider,
@@ -55,33 +65,20 @@ const providers: ProviderCard[] = [
       'Community Models',
     ],
     badge: 'Flexible',
+    pricing: {
+      per_second: 0.15,
+      samples: {
+        '1s': 0.15,
+        '8s': 1.2,
+        '30s': 4.5,
+        '60s': 9.0,
+      },
+      evidence: 'google/veo-3-fast with_audio — $0.15 per second',
+    },
   },
 ];
 
 export const ProviderSelect: React.FC<ProviderSelectProps> = ({ onSelect }) => {
-  const [liveProviders, setLiveProviders] = React.useState<typeof providers | null>(null);
-
-  React.useEffect(() => {
-    let mounted = true;
-    fetch('/api/pricing')
-      .then(res => res.json())
-      .then(data => {
-        if (!mounted) return;
-        // Merge fetched pricing into static provider metadata
-        const mapped = providers.map(p => {
-          const found = (data.providers || []).find((x: any) => x.id === (p.id === 'kling' ? 'kie' : p.id));
-          return { ...p, pricing: found?.pricing };
-        });
-        setLiveProviders(mapped);
-      })
-      .catch(() => {
-        /* ignore — fall back to static providers */
-      });
-    return () => { mounted = false; };
-  }, []);
-
-  const list = liveProviders || providers;
-
   return (
     <div className="min-h-[70vh] flex flex-col items-center justify-center p-8">
       {/* Hero Section */}
@@ -102,7 +99,7 @@ export const ProviderSelect: React.FC<ProviderSelectProps> = ({ onSelect }) => {
 
       {/* Provider Cards */}
       <div className="grid grid-cols-1 md:grid-cols-2 gap-8 max-w-5xl w-full">
-        {list.map((provider, index) => (
+        {providers.map((provider, index) => (
           <motion.div
             key={provider.id}
             initial={{ opacity: 0, y: 30 }}

frontend/src/components/SavedPromptsLibrary.tsx

@@ -0,0 +1,388 @@
+import { useEffect, useState } from 'react';
+
+const API_BASE = import.meta.env.VITE_API_BASE_URL || '';
+
+interface CachedPrompt {
+  prompt_id: string;
+  created_at: string;
+  updated_at: string;
+  metadata: {
+    script: string;
+    style: string;
+    model: string;
+    segments_count: number;
+  };
+  segments_count: number;
+}
+
+export function SavedPromptsLibrary({ onClose, onReuse }: { 
+  onClose: () => void;
+  onReuse: (payload: any) => void;
+}) {
+  const [prompts, setPrompts] = useState<CachedPrompt[]>([]);
+  const [loading, setLoading] = useState(true);
+  const [error, setError] = useState<string | null>(null);
+  const [editingPromptId, setEditingPromptId] = useState<string | null>(null);
+  const [editingPayloadJson, setEditingPayloadJson] = useState('');
+  const [editError, setEditError] = useState<string | null>(null);
+  const [saving, setSaving] = useState(false);
+  const [validating, setValidating] = useState(false);
+  const [validationResult, setValidationResult] = useState<{
+    valid: boolean;
+    schema_errors?: string[];
+    ai_checked?: boolean;
+    ai_valid?: boolean;
+    ai_warnings?: string[];
+    ai_suggestions?: string[];
+  } | null>(null);
+
+  useEffect(() => {
+    loadSavedPrompts();
+  }, []);
+
+  const loadSavedPrompts = async () => {
+    try {
+      setLoading(true);
+      setError(null);
+      const response = await fetch(`${API_BASE}/api/cached-prompts?limit=50`);
+      if (!response.ok) throw new Error('Failed to load prompts');
+      const data = await response.json();
+      const list: CachedPrompt[] = data.prompts || [];
+      // Deduplicate: same script + same segment count = same prompt; keep most recent
+      const seen = new Map<string, CachedPrompt>();
+      const key = (p: CachedPrompt) => {
+        const script = (p.metadata?.script || '').trim().slice(0, 300);
+        return `${script}|${p.segments_count ?? p.metadata?.segments_count ?? 0}`;
+      };
+      for (const p of list) {
+        const k = key(p);
+        const existing = seen.get(k);
+        if (!existing || new Date(p.updated_at) > new Date(existing.updated_at)) {
+          seen.set(k, p);
+        }
+      }
+      setPrompts(Array.from(seen.values()));
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'Failed to load prompts');
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  const handleReuse = async (promptId: string) => {
+    try {
+      const response = await fetch(`${API_BASE}/api/use-cached-prompt/${promptId}`, {
+        method: 'POST'
+      });
+      if (!response.ok) throw new Error('Failed to load prompt');
+      const { payload } = await response.json();
+      onReuse(payload);
+      onClose();
+    } catch (err) {
+      alert(err instanceof Error ? err.message : 'Failed to reuse prompt');
+    }
+  };
+
+  const handleDelete = async (promptId: string) => {
+    if (!confirm('Delete this saved prompt?')) return;
+    
+    try {
+      await fetch(`${API_BASE}/api/cached-prompts/${promptId}`, { method: 'DELETE' });
+      loadSavedPrompts(); // Refresh list
+    } catch (err) {
+      alert('Failed to delete prompt');
+    }
+  };
+
+  const handleEdit = async (promptId: string) => {
+    setEditError(null);
+    try {
+      const response = await fetch(`${API_BASE}/api/cached-prompts/${promptId}`);
+      if (!response.ok) throw new Error('Failed to load prompt');
+      const entry = await response.json();
+      const payload = entry.payload ?? { segments: entry.segments ?? [] };
+      setEditingPayloadJson(JSON.stringify(payload, null, 2));
+      setEditingPromptId(promptId);
+    } catch (err) {
+      setEditError(err instanceof Error ? err.message : 'Failed to load prompt');
+    }
+  };
+
+  const validatePayload = (): { valid: boolean; payload?: any; error?: string } => {
+    try {
+      const parsed = JSON.parse(editingPayloadJson);
+      if (!parsed || typeof parsed !== 'object') return { valid: false, error: 'Payload must be an object' };
+      if (!Array.isArray(parsed.segments)) return { valid: false, error: 'Payload must have a "segments" array' };
+      return { valid: true, payload: parsed };
+    } catch {
+      return { valid: false, error: 'Invalid JSON' };
+    }
+  };
+
+  const handleValidateWithAi = async () => {
+    const { valid, payload, error } = validatePayload();
+    if (!valid || !payload) {
+      setEditError(error ?? 'Invalid payload');
+      setValidationResult(null);
+      return;
+    }
+    setEditError(null);
+    setValidationResult(null);
+    setValidating(true);
+    try {
+      const response = await fetch(`${API_BASE}/api/validate-payload`, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify({ payload, use_ai: true }),
+      });
+      const data = await response.json().catch(() => ({}));
+      if (!response.ok) throw new Error(data.detail || response.statusText || 'Validation failed');
+      setValidationResult({
+        valid: data.valid,
+        schema_errors: data.schema_errors,
+        ai_checked: data.ai_checked,
+        ai_valid: data.ai_valid,
+        ai_warnings: data.ai_warnings,
+        ai_suggestions: data.ai_suggestions,
+      });
+    } catch (err) {
+      setEditError(err instanceof Error ? err.message : 'Validation request failed');
+    } finally {
+      setValidating(false);
+    }
+  };
+
+  const handleSaveEdit = async () => {
+    const { valid, payload, error } = validatePayload();
+    if (!valid || !payload || !editingPromptId) {
+      setEditError(error ?? 'Invalid payload');
+      return;
+    }
+    setEditError(null);
+    setSaving(true);
+    try {
+      const response = await fetch(`${API_BASE}/api/cached-prompts/${editingPromptId}`, {
+        method: 'PUT',
+        headers: { 'Content-Type': 'application/json' },
+        body: JSON.stringify(payload),
+      });
+      if (!response.ok) {
+        const errData = await response.json().catch(() => ({}));
+        throw new Error(errData.detail || response.statusText || 'Failed to update');
+      }
+      setEditingPromptId(null);
+      setEditingPayloadJson('');
+      loadSavedPrompts();
+    } catch (err) {
+      setEditError(err instanceof Error ? err.message : 'Failed to save');
+    } finally {
+      setSaving(false);
+    }
+  };
+
+  const closeEditModal = () => {
+    setEditingPromptId(null);
+    setEditingPayloadJson('');
+    setEditError(null);
+    setValidationResult(null);
+  };
+
+  return (
+    <div className="fixed inset-0 bg-void-950/80 backdrop-blur-sm flex items-center justify-center p-4 z-50">
+      <div className="bg-void-900/95 backdrop-blur-xl rounded-2xl shadow-2xl border border-void-700/50 max-w-4xl w-full max-h-[90vh] overflow-hidden flex flex-col">
+        {/* Header */}
+        <div className="p-6 border-b border-void-700/50 flex justify-between items-center">
+          <h2 className="text-2xl font-bold text-void-100">💾 My Saved Prompts</h2>
+          <button 
+            onClick={onClose}
+            className="text-void-400 hover:text-void-100 text-2xl font-light leading-none transition-colors"
+          >
+            ×
+          </button>
+        </div>
+
+        {/* Content */}
+        <div className="flex-1 overflow-y-auto p-6">
+          {loading ? (
+            <div className="flex items-center justify-center py-12">
+              <div className="animate-spin rounded-full h-12 w-12 border-2 border-void-600 border-t-coral-500" />
+            </div>
+          ) : error ? (
+            <div className="text-center py-12">
+              <p className="text-coral-400 mb-4">{error}</p>
+              <button 
+                onClick={loadSavedPrompts}
+                className="px-4 py-2 bg-coral-500/20 text-coral-400 rounded-xl border border-coral-500/50 hover:bg-coral-500/30 transition-colors"
+              >
+                Retry
+              </button>
+            </div>
+          ) : prompts.length === 0 ? (
+            <div className="text-center py-12">
+              <div className="text-6xl mb-4 opacity-60">📭</div>
+              <p className="text-void-300 mb-2">No saved prompts yet</p>
+              <p className="text-sm text-void-500">Generate some prompts to see them here</p>
+            </div>
+          ) : (
+            <div className="grid grid-cols-1 md:grid-cols-2 gap-4">
+              {prompts.map((prompt) => (
+                <div 
+                  key={prompt.prompt_id}
+                  className="card hover:border-void-600/50 hover:bg-void-800/40 transition-all duration-200"
+                >
+                  {/* Header */}
+                  <div className="flex justify-between items-start mb-3">
+                    <span className="text-xs text-void-500">
+                      {new Date(prompt.created_at).toLocaleDateString('en-US', {
+                        month: 'short',
+                        day: 'numeric',
+                        year: 'numeric'
+                      })}
+                    </span>
+                    <span className="px-2 py-1 bg-electric-500/20 text-electric-400 text-xs rounded-full font-medium border border-electric-500/30">
+                      {prompt.segments_count} segments
+                    </span>
+                  </div>
+
+                  {/* Content Preview */}
+                  <div className="mb-4">
+                    <p className="text-sm text-void-200 line-clamp-3 mb-2">
+                      {(prompt.metadata?.script || '').slice(0, 120)}
+                      {(prompt.metadata?.script || '').length > 120 ? '…' : ''}
+                    </p>
+                    <span className="inline-block px-2 py-1 bg-void-800 text-void-300 text-xs rounded-lg border border-void-600/50">
+                      {prompt.metadata?.style || '—'}
+                    </span>
+                  </div>
+
+                  {/* Actions */}
+                  <div className="flex gap-2">
+                    <button 
+                      onClick={() => handleReuse(prompt.prompt_id)}
+                      className="flex-1 px-3 py-2 bg-coral-500/20 text-coral-400 rounded-xl border border-coral-500/50 hover:bg-coral-500/30 text-sm font-medium transition-colors"
+                    >
+                      ♻️ Reuse
+                    </button>
+                    <button 
+                      onClick={() => handleEdit(prompt.prompt_id)}
+                      className="px-3 py-2 bg-void-800 text-void-300 rounded-xl border border-void-600 hover:bg-void-700 hover:text-void-100 text-sm transition-colors"
+                      title="Edit prompt"
+                    >
+                      ✏️
+                    </button>
+                    <button 
+                      onClick={() => handleDelete(prompt.prompt_id)}
+                      className="px-3 py-2 bg-void-800/80 text-red-400 rounded-xl border border-void-600 hover:bg-red-500/10 hover:border-red-500/40 text-sm transition-colors"
+                    >
+                      🗑️
+                    </button>
+                  </div>
+                </div>
+              ))}
+            </div>
+          )}
+        </div>
+
+        {/* Footer */}
+        <div className="p-4 border-t border-void-700/50">
+          <button 
+            onClick={onClose}
+            className="w-full py-2.5 bg-void-800 text-void-200 rounded-xl border border-void-600 hover:bg-void-700 transition-colors"
+          >
+            Close
+          </button>
+        </div>
+      </div>
+
+        {/* Edit modal - dark chrome to match app; light body so JSON is readable */}
+        {editingPromptId && (
+          <div className="fixed inset-0 bg-void-950/90 backdrop-blur-sm flex items-center justify-center p-4 z-[60]">
+            <div className="bg-void-900 rounded-2xl shadow-2xl max-w-4xl w-full max-h-[90vh] overflow-hidden flex flex-col border border-void-600">
+              <div className="p-4 border-b border-void-600 flex justify-between items-center">
+                <h3 className="text-lg font-bold text-void-100">✏️ Edit saved prompt</h3>
+                <button onClick={closeEditModal} className="text-void-400 hover:text-void-100 text-2xl font-bold leading-none transition-colors">×</button>
+              </div>
+              <div className="flex-1 overflow-hidden flex flex-col p-4 bg-void-800/30">
+                {editError && (
+                  <p className="text-coral-400 text-sm mb-2 font-medium">{editError}</p>
+                )}
+                {validationResult && (
+                  <div className="mb-3 p-3 rounded-xl bg-void-900/80 border border-void-600 text-sm">
+                    {!validationResult.valid && validationResult.schema_errors && validationResult.schema_errors.length > 0 && (
+                      <div className="mb-2">
+                        <p className="font-medium text-coral-400 mb-1">Schema issues:</p>
+                        <ul className="list-disc list-inside text-coral-300/90 space-y-0.5">
+                          {validationResult.schema_errors.map((e, i) => (
+                            <li key={i}>{e}</li>
+                          ))}
+                        </ul>
+                      </div>
+                    )}
+                    {validationResult.ai_checked && (
+                      <>
+                        {validationResult.ai_warnings && validationResult.ai_warnings.length > 0 && (
+                          <div className="mb-2">
+                            <p className="font-medium text-amber-400 mb-1">AI review warnings:</p>
+                            <ul className="list-disc list-inside text-amber-300/90 space-y-0.5">
+                              {validationResult.ai_warnings.map((w, i) => (
+                                <li key={i}>{w}</li>
+                              ))}
+                            </ul>
+                          </div>
+                        )}
+                        {validationResult.ai_suggestions && validationResult.ai_suggestions.length > 0 && (
+                          <div className="mb-2">
+                            <p className="font-medium text-electric-400 mb-1">Suggestions:</p>
+                            <ul className="list-disc list-inside text-electric-300/90 space-y-0.5">
+                              {validationResult.ai_suggestions.map((s, i) => (
+                                <li key={i}>{s}</li>
+                              ))}
+                            </ul>
+                          </div>
+                        )}
+                        {validationResult.valid && (!validationResult.ai_warnings?.length) && (!validationResult.ai_suggestions?.length) && validationResult.ai_valid !== false && (
+                          <p className="text-electric-400 font-medium">✓ Schema and AI review passed.</p>
+                        )}
+                      </>
+                    )}
+                  </div>
+                )}
+                <p className="text-sm text-void-300 mb-2">
+                  Edit the JSON below. Keep the <code className="bg-void-700 text-void-100 px-1.5 py-0.5 rounded font-mono text-xs">segments</code> array structure. Use &quot;Validate with AI&quot; to check schema and content.
+                </p>
+                <textarea
+                  value={editingPayloadJson}
+                  onChange={(e) => { setEditingPayloadJson(e.target.value); setValidationResult(null); }}
+                  className="flex-1 w-full p-4 font-mono text-sm text-void-100 bg-void-950 border border-void-600 rounded-xl resize-none min-h-[320px] placeholder-void-500 focus:border-coral-500/50 focus:ring-2 focus:ring-coral-500/20 focus:outline-none"
+                  spellCheck={false}
+                  placeholder='{"segments": [...]}'
+                />
+                <div className="flex gap-2 mt-3">
+                  <button
+                    onClick={handleValidateWithAi}
+                    disabled={validating}
+                    className="px-4 py-2 bg-amber-500/20 text-amber-400 rounded-xl border border-amber-500/40 hover:bg-amber-500/30 disabled:opacity-50 text-sm font-medium transition-colors"
+                  >
+                    {validating ? 'Validating…' : 'Validate with AI'}
+                  </button>
+                  <button
+                    onClick={handleSaveEdit}
+                    disabled={saving}
+                    className="px-4 py-2 bg-coral-500/20 text-coral-400 rounded-xl border border-coral-500/50 hover:bg-coral-500/30 disabled:opacity-50 text-sm font-medium transition-colors"
+                  >
+                    {saving ? 'Saving…' : 'Save changes'}
+                  </button>
+                  <button
+                    onClick={closeEditModal}
+                    className="px-4 py-2 bg-void-800 text-void-300 rounded-xl border border-void-600 hover:bg-void-700 hover:text-void-100 text-sm font-medium transition-colors"
+                  >
+                    Cancel
+                  </button>
+                </div>
+              </div>
+            </div>
+          </div>
+        )}
+    </div>
+  );
+}

frontend/src/components/SegmentGenerationProgress.tsx

@@ -0,0 +1,221 @@
+import { useEffect, useState } from 'react';
+
+interface Props {
+  segmentsCount: number;
+  currentSegmentIndex?: number;  // Optional for streaming mode
+  realProgress?: number;  // Optional for streaming mode
+  generatedSegments?: any[];  // Optional for streaming mode
+  onCancel?: () => void;
+  isStreaming?: boolean;  // If true, use real progress; if false, simulate
+}
+
+const GENERATION_TIPS = [
+  "💡 AI is analyzing your reference image for character details...",
+  "🎬 Creating detailed camera movements for cinematic quality...",
+  "👤 Generating character descriptions with exact physical features...",
+  "🎭 Crafting micro-expressions and natural gestures...",
+  "🎨 Designing scene continuity for seamless video flow...",
+  "🎯 Ensuring dialogue syncs perfectly with actions...",
+  "✨ Adding production-quality details to each segment...",
+  "🔍 Cross-checking consistency across all segments...",
+  "💾 Auto-saving your prompts for recovery...",
+  "🎪 Almost done! Finalizing segment specifications..."
+];
+
+export function SegmentGenerationProgress({ segmentsCount, onCancel }: Props) {
+  const [progress, setProgress] = useState(0);
+  const [currentTip, setCurrentTip] = useState(0);
+  const [elapsedTime, setElapsedTime] = useState(0);
+  const [estimatedTime] = useState(
+    segmentsCount <= 2 ? 20 : segmentsCount <= 5 ? 50 : 90
+  );
+
+  // Progress simulation (realistic timing based on actual API performance)
+  useEffect(() => {
+    const interval = setInterval(() => {
+      setProgress(prev => {
+        // Slow start (first 30%), medium middle (30-80%), slow end (80-100%)
+        if (prev < 30) return prev + 0.5; // Slow start
+        if (prev < 80) return prev + 0.8; // Medium speed
+        if (prev < 95) return prev + 0.2; // Slow down near end
+        return prev; // Stop at 95% until actual completion
+      });
+    }, 1000);
+
+    return () => clearInterval(interval);
+  }, []);
+
+  // Tip rotation
+  useEffect(() => {
+    const interval = setInterval(() => {
+      setCurrentTip(prev => (prev + 1) % GENERATION_TIPS.length);
+    }, 4000); // Change tip every 4 seconds
+
+    return () => clearInterval(interval);
+  }, []);
+
+  // Elapsed time counter
+  useEffect(() => {
+    const interval = setInterval(() => {
+      setElapsedTime(prev => prev + 1);
+    }, 1000);
+
+    return () => clearInterval(interval);
+  }, []);
+
+  const formatTime = (seconds: number) => {
+    const mins = Math.floor(seconds / 60);
+    const secs = seconds % 60;
+    return mins > 0 ? `${mins}m ${secs}s` : `${secs}s`;
+  };
+
+  return (
+    <div className="max-w-2xl mx-auto p-8 glass-dark rounded-2xl shadow-2xl border-2 border-void-700/50">
+      {/* Header */}
+      <div className="flex justify-between items-center mb-6">
+        <div className="flex items-center gap-2 bg-coral-500/20 px-4 py-2 rounded-full border border-coral-500/30">
+          <div className="w-2 h-2 bg-coral-400 rounded-full animate-pulse" />
+          <span className="text-sm font-medium text-void-100">Generating {segmentsCount} segments</span>
+        </div>
+        
+        <div className="font-mono text-lg font-bold text-void-100">
+          <span className="text-coral-400">{formatTime(elapsedTime)}</span>
+          <span className="text-void-600 mx-1">/</span>
+          <span className="text-void-400">~{formatTime(estimatedTime)}</span>
+        </div>
+      </div>
+
+      {/* Progress Bar */}
+      <div className="relative h-10 bg-void-900/80 border border-void-700 rounded-full overflow-hidden mb-8">
+        <div 
+          className="h-full bg-gradient-to-r from-coral-500 to-electric-500 rounded-full transition-all duration-500 ease-out relative"
+          style={{ width: `${progress}%` }}
+        >
+          <div className="absolute inset-0 bg-gradient-to-r from-transparent via-white/20 to-transparent animate-shimmer" />
+        </div>
+        <span className="absolute inset-0 flex items-center justify-center font-bold text-void-100 drop-shadow-lg">
+          {Math.round(progress)}%
+        </span>
+      </div>
+
+      {/* Generation Steps */}
+      <div className="grid grid-cols-4 gap-4 mb-8">
+        <GenerationStep 
+          icon="🔍"
+          label="Analyzing"
+          status={progress < 20 ? 'active' : 'complete'}
+        />
+        <GenerationStep 
+          icon="🎬"
+          label="Creating"
+          status={progress < 20 ? 'pending' : progress < 80 ? 'active' : 'complete'}
+        />
+        <GenerationStep 
+          icon="✅"
+          label="Validating"
+          status={progress < 80 ? 'pending' : progress < 95 ? 'active' : 'complete'}
+        />
+        <GenerationStep 
+          icon="💾"
+          label="Saving"
+          status={progress < 95 ? 'pending' : 'active'}
+        />
+      </div>
+
+      {/* Rotating Tips */}
+      <div 
+        key={currentTip}
+        className="bg-void-900/60 backdrop-blur-sm p-4 rounded-xl mb-8 flex items-center gap-3 min-h-[60px] animate-fade-in border border-void-700/50"
+      >
+        <span className="text-2xl">💡</span>
+        <p className="text-sm leading-relaxed text-void-200">{GENERATION_TIPS[currentTip]}</p>
+      </div>
+
+      {/* Segments Preview */}
+      <div className="mb-6">
+        <h4 className="text-sm mb-3 text-void-300 font-semibold">Segments Being Generated:</h4>
+        <div className="grid grid-cols-4 sm:grid-cols-8 gap-2">
+          {Array.from({ length: segmentsCount }).map((_, i) => (
+            <SegmentCard
+              key={i}
+              number={i + 1}
+              status={
+                progress > (i / segmentsCount) * 100 ? 'complete' : 
+                progress > ((i - 0.5) / segmentsCount) * 100 ? 'generating' : 
+                'pending'
+              }
+            />
+          ))}
+        </div>
+      </div>
+
+      {/* Auto-Save Indicator */}
+      <div className="flex items-center justify-center gap-2 mb-6 text-sm text-void-300">
+        <span className={progress < 95 ? '' : 'animate-spin'}>💾</span>
+        <span>Auto-saving prompts for recovery...</span>
+      </div>
+
+      {/* Cancel Button */}
+      {onCancel && (
+        <button 
+          onClick={onCancel}
+          className="w-full py-3 bg-red-500/20 border border-red-500/50 rounded-lg hover:bg-red-500/30 transition-colors text-void-100 font-medium"
+        >
+          Cancel Generation
+        </button>
+      )}
+    </div>
+  );
+}
+
+function GenerationStep({ icon, label, status }: {
+  icon: string;
+  label: string;
+  status: 'pending' | 'active' | 'complete';
+}) {
+  return (
+    <div className="flex flex-col items-center gap-2">
+      <div className={`
+        w-12 h-12 rounded-full flex items-center justify-center text-xl transition-all border-2
+        ${status === 'complete' ? 'bg-electric-500/30 border-electric-400 shadow-lg shadow-electric-500/50' : ''}
+        ${status === 'active' ? 'bg-coral-500/30 border-coral-400 shadow-lg shadow-coral-500/50 animate-pulse' : ''}
+        ${status === 'pending' ? 'bg-void-900/50 border-void-700' : ''}
+      `}>
+        <span className={status === 'complete' ? 'text-electric-300' : status === 'active' ? 'text-coral-300' : 'text-void-500'}>
+          {status === 'complete' ? '✓' : icon}
+        </span>
+      </div>
+      <span className={`text-xs ${status === 'active' ? 'font-semibold text-coral-300' : status === 'complete' ? 'text-electric-300' : 'text-void-400'}`}>
+        {label}
+      </span>
+    </div>
+  );
+}
+
+function SegmentCard({ number, status }: {
+  number: number;
+  status: 'pending' | 'generating' | 'complete';
+}) {
+  return (
+    <div className={`
+      p-2 rounded-lg text-center transition-all border-2
+      ${status === 'complete' ? 'bg-electric-500/20 border-electric-500/50 shadow-lg shadow-electric-500/20' : ''}
+      ${status === 'generating' ? 'bg-coral-500/20 border-coral-500/50 shadow-lg shadow-coral-500/30 animate-pulse' : ''}
+      ${status === 'pending' ? 'bg-void-900/50 border-void-700' : ''}
+    `}>
+      <div className={`font-bold text-xs ${status === 'complete' ? 'text-electric-300' : status === 'generating' ? 'text-coral-300' : 'text-void-400'}`}>
+        #{number}
+      </div>
+      <div className="text-lg">
+        {status === 'complete' && <span className="text-electric-400">✓</span>}
+        {status === 'generating' && <span className="animate-spin inline-block">⚙️</span>}
+        {status === 'pending' && <span className="text-void-500">⏳</span>}
+      </div>
+      <div className={`text-[10px] font-medium ${status === 'complete' ? 'text-electric-400' : status === 'generating' ? 'text-coral-400' : 'text-void-500'}`}>
+        {status === 'complete' && 'Ready'}
+        {status === 'generating' && 'Queue'}
+        {status === 'pending' && 'Queue'}
+      </div>
+    </div>
+  );
+}

frontend/src/components/SegmentPromptsViewer.tsx

@@ -0,0 +1,304 @@
+import { useState } from 'react';
+import { motion, AnimatePresence } from 'framer-motion';
+import type { VeoSegment } from '@/types';
+import { ChevronDownIcon, CopyIcon, CheckIcon } from './Icons';
+
+interface SegmentPromptsViewerProps {
+  segments: VeoSegment[];
+  accentColor: 'coral' | 'electric';
+}
+
+export const SegmentPromptsViewer: React.FC<SegmentPromptsViewerProps> = ({ 
+  segments, 
+  accentColor 
+}) => {
+  const [isOpen, setIsOpen] = useState(false);
+  const [expandedSegments, setExpandedSegments] = useState<Set<number>>(new Set());
+  const [copiedIndex, setCopiedIndex] = useState<number | null>(null);
+
+  const toggleSegment = (index: number) => {
+    const newExpanded = new Set(expandedSegments);
+    if (newExpanded.has(index)) {
+      newExpanded.delete(index);
+    } else {
+      newExpanded.add(index);
+    }
+    setExpandedSegments(newExpanded);
+  };
+
+  const expandAll = () => {
+    setExpandedSegments(new Set(segments.map((_, i) => i)));
+  };
+
+  const collapseAll = () => {
+    setExpandedSegments(new Set());
+  };
+
+  const copySegment = (segment: VeoSegment, index: number) => {
+    const formatted = JSON.stringify(segment, null, 2);
+    navigator.clipboard.writeText(formatted);
+    setCopiedIndex(index);
+    setTimeout(() => setCopiedIndex(null), 2000);
+  };
+
+  const copyAllSegments = () => {
+    const formatted = JSON.stringify({ segments }, null, 2);
+    navigator.clipboard.writeText(formatted);
+    setCopiedIndex(-1);
+    setTimeout(() => setCopiedIndex(null), 2000);
+  };
+
+  if (segments.length === 0) return null;
+
+  return (
+    <div className="mb-8">
+      <button
+        onClick={() => setIsOpen(!isOpen)}
+        className={`
+          w-full card border-2 transition-colors
+          ${accentColor === 'coral' 
+            ? 'border-coral-500/30 hover:border-coral-500/50' 
+            : 'border-electric-500/30 hover:border-electric-500/50'
+          }
+        `}
+      >
+        <div className="flex items-center justify-between">
+          <div className="flex items-center gap-3">
+            <div className={`p-2 rounded-lg ${accentColor === 'coral' ? 'bg-coral-500/20' : 'bg-electric-500/20'}`}>
+              <svg className={`w-5 h-5 ${accentColor === 'coral' ? 'text-coral-400' : 'text-electric-400'}`} fill="none" stroke="currentColor" viewBox="0 0 24 24">
+                <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M9 12h6m-6 4h6m2 5H7a2 2 0 01-2-2V5a2 2 0 012-2h5.586a1 1 0 01.707.293l5.414 5.414a1 1 0 01.293.707V19a2 2 0 01-2 2z" />
+              </svg>
+            </div>
+            <div className="text-left">
+              <h3 className="font-bold text-void-100">View Segment Prompts</h3>
+              <p className="text-sm text-void-400">
+                {segments.length} detailed AI-generated prompts
+              </p>
+            </div>
+          </div>
+          <motion.div
+            animate={{ rotate: isOpen ? 180 : 0 }}
+            transition={{ duration: 0.2 }}
+          >
+            <ChevronDownIcon size={24} className="text-void-400" />
+          </motion.div>
+        </div>
+      </button>
+
+      <AnimatePresence>
+        {isOpen && (
+          <motion.div
+            initial={{ opacity: 0, height: 0 }}
+            animate={{ opacity: 1, height: 'auto' }}
+            exit={{ opacity: 0, height: 0 }}
+            transition={{ duration: 0.3 }}
+            className="overflow-hidden"
+          >
+            <div className="mt-4 space-y-4">
+              {/* Controls */}
+              <div className="flex items-center justify-between gap-3 flex-wrap">
+                <div className="flex gap-2">
+                  <button
+                    onClick={expandAll}
+                    className="btn-secondary-sm"
+                  >
+                    Expand All
+                  </button>
+                  <button
+                    onClick={collapseAll}
+                    className="btn-secondary-sm"
+                  >
+                    Collapse All
+                  </button>
+                </div>
+                <button
+                  onClick={copyAllSegments}
+                  className={`
+                    flex items-center gap-2 px-3 py-1.5 rounded-lg text-sm font-medium transition-colors
+                    ${accentColor === 'coral'
+                      ? 'bg-coral-500/10 text-coral-400 hover:bg-coral-500/20'
+                      : 'bg-electric-500/10 text-electric-400 hover:bg-electric-500/20'
+                    }
+                  `}
+                >
+                  {copiedIndex === -1 ? (
+                    <>
+                      <CheckIcon size={16} />
+                      Copied All!
+                    </>
+                  ) : (
+                    <>
+                      <CopyIcon size={16} />
+                      Copy All JSON
+                    </>
+                  )}
+                </button>
+              </div>
+
+              {/* Segment Cards */}
+              <div className="space-y-3">
+                {segments.map((segment, index) => {
+                  const isExpanded = expandedSegments.has(index);
+                  
+                  return (
+                    <div
+                      key={index}
+                      className="card border border-void-700 hover:border-void-600 transition-colors"
+                    >
+                      {/* Segment Header */}
+                      <div className="flex items-start justify-between gap-4">
+                        <button
+                          onClick={() => toggleSegment(index)}
+                          className="flex-1 text-left"
+                        >
+                          <div className="flex items-center gap-3 mb-2">
+                            <span className={`
+                              px-2.5 py-0.5 rounded-full text-xs font-bold
+                              ${accentColor === 'coral' 
+                                ? 'bg-coral-500/20 text-coral-400' 
+                                : 'bg-electric-500/20 text-electric-400'
+                              }
+                            `}>
+                              Segment {index + 1}
+                            </span>
+                            <motion.div
+                              animate={{ rotate: isExpanded ? 180 : 0 }}
+                              transition={{ duration: 0.2 }}
+                            >
+                              <ChevronDownIcon size={16} className="text-void-400" />
+                            </motion.div>
+                          </div>
+                          <p className="text-sm text-void-300 line-clamp-2">
+                            {segment.action_timeline?.dialogue || 'No dialogue'}
+                          </p>
+                        </button>
+                        <button
+                          onClick={() => copySegment(segment, index)}
+                          className="p-2 rounded-lg hover:bg-void-800 transition-colors text-void-400 hover:text-void-200"
+                          title="Copy segment JSON"
+                        >
+                          {copiedIndex === index ? (
+                            <CheckIcon size={16} className="text-green-400" />
+                          ) : (
+                            <CopyIcon size={16} />
+                          )}
+                        </button>
+                      </div>
+
+                      {/* Expanded Content */}
+                      <AnimatePresence>
+                        {isExpanded && (
+                          <motion.div
+                            initial={{ opacity: 0, height: 0 }}
+                            animate={{ opacity: 1, height: 'auto' }}
+                            exit={{ opacity: 0, height: 0 }}
+                            className="overflow-hidden"
+                          >
+                            <div className="mt-4 pt-4 border-t border-void-700 space-y-4 text-sm">
+                              {/* Dialogue */}
+                              <div>
+                                <h4 className="font-semibold text-void-200 mb-2">Dialogue</h4>
+                                <p className="text-void-400 bg-void-900/50 p-3 rounded-lg">
+                                  "{segment.action_timeline?.dialogue}"
+                                </p>
+                              </div>
+
+                              {/* Character Description */}
+                              <div>
+                                <h4 className="font-semibold text-void-200 mb-2">Character</h4>
+                                <div className="space-y-2">
+                                  <div>
+                                    <span className="text-xs text-void-500 uppercase tracking-wide">Current State:</span>
+                                    <p className="text-void-400 bg-void-900/50 p-2 rounded mt-1 text-xs leading-relaxed">
+                                      {segment.character_description?.current_state}
+                                    </p>
+                                  </div>
+                                  <div>
+                                    <span className="text-xs text-void-500 uppercase tracking-wide">Voice Matching:</span>
+                                    <p className="text-void-400 bg-void-900/50 p-2 rounded mt-1 text-xs leading-relaxed">
+                                      {segment.character_description?.voice_matching}
+                                    </p>
+                                  </div>
+                                </div>
+                              </div>
+
+                              {/* Scene Continuity */}
+                              <div>
+                                <h4 className="font-semibold text-void-200 mb-2">Scene</h4>
+                                <div className="space-y-2">
+                                  <div>
+                                    <span className="text-xs text-void-500 uppercase tracking-wide">Environment:</span>
+                                    <p className="text-void-400 bg-void-900/50 p-2 rounded mt-1 text-xs leading-relaxed">
+                                      {segment.scene_continuity?.environment}
+                                    </p>
+                                  </div>
+                                  <div>
+                                    <span className="text-xs text-void-500 uppercase tracking-wide">Camera:</span>
+                                    <p className="text-void-400 bg-void-900/50 p-2 rounded mt-1 text-xs leading-relaxed">
+                                      {segment.scene_continuity?.camera_position} • {segment.scene_continuity?.camera_movement}
+                                    </p>
+                                  </div>
+                                  <div>
+                                    <span className="text-xs text-void-500 uppercase tracking-wide">Lighting:</span>
+                                    <p className="text-void-400 bg-void-900/50 p-2 rounded mt-1 text-xs leading-relaxed">
+                                      {segment.scene_continuity?.lighting_state}
+                                    </p>
+                                  </div>
+                                </div>
+                              </div>
+
+                              {/* Synchronized Actions */}
+                              <div>
+                                <h4 className="font-semibold text-void-200 mb-2">Timeline</h4>
+                                <div className="space-y-1.5">
+                                  {Object.entries(segment.action_timeline?.synchronized_actions || {}).map(([time, action]) => (
+                                    <div key={time} className="flex gap-3">
+                                      <span className={`
+                                        text-xs font-mono px-2 py-1 rounded
+                                        ${accentColor === 'coral' 
+                                          ? 'bg-coral-500/10 text-coral-400' 
+                                          : 'bg-electric-500/10 text-electric-400'
+                                        }
+                                      `}>
+                                        {time}
+                                      </span>
+                                      <p className="text-void-400 text-xs flex-1">
+                                        {action}
+                                      </p>
+                                    </div>
+                                  ))}
+                                </div>
+                              </div>
+
+                              {/* Segment Info */}
+                              <div className="pt-3 border-t border-void-800">
+                                <div className="grid grid-cols-2 gap-3 text-xs">
+                                  <div>
+                                    <span className="text-void-500">Duration:</span>
+                                    <span className="text-void-300 ml-2 font-medium">
+                                      {segment.segment_info?.duration}
+                                    </span>
+                                  </div>
+                                  <div>
+                                    <span className="text-void-500">Location:</span>
+                                    <span className="text-void-300 ml-2 font-medium">
+                                      {segment.segment_info?.location}
+                                    </span>
+                                  </div>
+                                </div>
+                              </div>
+                            </div>
+                          </motion.div>
+                        )}
+                      </AnimatePresence>
+                    </div>
+                  );
+                })}
+              </div>
+            </div>
+          </motion.div>
+        )}
+      </AnimatePresence>
+    </div>
+  );
+};

frontend/src/components/index.ts

@@ -5,4 +5,7 @@ export * from './GenerationProgress';
 export * from './GenerationComplete';
 export * from './ErrorDisplay';
 export * from './Login';
+export * from './SegmentGenerationProgress';
+export * from './SavedPromptsLibrary';
+export * from './SegmentPromptsViewer';
 

frontend/src/context/GenerationContext.tsx

@@ -1,4 +1,4 @@
-import React, { createContext, useContext, useReducer, ReactNode } from 'react';
+import React, { createContext, useContext, useReducer, useRef, ReactNode } from 'react';
 import type { 
   GenerationState, 
   GenerationStep, 
@@ -24,6 +24,7 @@ const initialState: GenerationState = {
   retryState: null,
   activeTaskIds: [] as string[],
   isCancelling: false,
+  partialCompletionError: null,
 };
 
 // Action types
@@ -36,10 +37,11 @@ type GenerationAction =
   | { type: 'SET_PROGRESS'; payload: { current?: number; total?: number; message?: string } }
   | { type: 'SET_ERROR'; payload: string | null }
   | { type: 'SET_TASK_ID'; payload: string | null }
-  | { type: 'SET_RETRY_STATE'; payload: { failedSegmentIndex: number; error: string } | null }
+  | { type: 'SET_RETRY_STATE'; payload: { failedSegmentIndex: number; error: string; attemptCount: number } | null }
   | { type: 'ADD_TASK_ID'; payload: string }
   | { type: 'REMOVE_TASK_ID'; payload: string }
   | { type: 'SET_CANCELLING'; payload: boolean }
+  | { type: 'SET_PARTIAL_COMPLETION_ERROR'; payload: string | null }
   | { type: 'RESET' };
 
 // Reducer
@@ -75,6 +77,8 @@ function generationReducer(state: GenerationState, action: GenerationAction): Ge
       return { ...state, activeTaskIds: state.activeTaskIds.filter(id => id !== action.payload) };
     case 'SET_CANCELLING':
       return { ...state, isCancelling: action.payload };
+    case 'SET_PARTIAL_COMPLETION_ERROR':
+      return { ...state, partialCompletionError: action.payload };
     case 'RESET':
       return { ...initialState, provider: state.provider };
     default:
@@ -95,11 +99,13 @@ interface GenerationContextValue {
   addVideo: (video: GeneratedVideo) => void;
   updateProgress: (message: string, current?: number, total?: number) => void;
   setError: (error: string | null) => void;
-  setRetryState: (state: { failedSegmentIndex: number; error: string } | null) => void;
+  setRetryState: (state: { failedSegmentIndex: number; error: string; attemptCount: number } | null) => void;
   updateSegments: (segments: VeoSegment[]) => void;
   addTaskId: (taskId: string) => void;
   removeTaskId: (taskId: string) => void;
+  registerPromptAbortController: (controller: AbortController | null) => void;
   cancelGeneration: () => Promise<void>;
+  setPartialCompletionError: (error: string | null) => void;
   reset: () => void;
 }
 
@@ -108,6 +114,9 @@ const GenerationContext = createContext<GenerationContextValue | null>(null);
 // Provider component
 export function GenerationProvider({ children }: { children: ReactNode }) {
   const [state, dispatch] = useReducer(generationReducer, initialState);
+  const promptAbortRef = useRef<AbortController | null>(null);
+  const stateRef = useRef(state);
+  stateRef.current = state;
 
   const value: GenerationContextValue = {
     state,
@@ -170,25 +179,55 @@ export function GenerationProvider({ children }: { children: ReactNode }) {
       dispatch({ type: 'REMOVE_TASK_ID', payload: taskId });
     },
 
+    setPartialCompletionError: (error) => {
+      dispatch({ type: 'SET_PARTIAL_COMPLETION_ERROR', payload: error });
+    },
+
+    registerPromptAbortController: (controller) => {
+      promptAbortRef.current = controller;
+    },
+
     cancelGeneration: async () => {
       dispatch({ type: 'SET_CANCELLING', payload: true });
       try {
-        const { klingCancel } = await import('@/utils/api');
-        // Cancel all active tasks
-        const currentTaskIds = [...state.activeTaskIds];
-        const cancelPromises = currentTaskIds.map(taskId => 
-          klingCancel(taskId).catch(err => {
-            console.warn(`Failed to cancel task ${taskId}:`, err);
-          })
-        );
-        await Promise.all(cancelPromises);
-        // Clear all task IDs
-        currentTaskIds.forEach(id => {
-          dispatch({ type: 'REMOVE_TASK_ID', payload: id });
-        });
-        dispatch({ type: 'SET_TASK_ID', payload: null });
-        dispatch({ type: 'SET_ERROR', payload: 'Generation cancelled by user' });
-        dispatch({ type: 'SET_STEP', payload: 'error' });
+        const s = stateRef.current;
+        const currentStep = s.step;
+        const segmentCount = s.segments.length;
+        const videoCount = s.generatedVideos.length;
+
+        if (currentStep === 'generating_prompts') {
+          if (promptAbortRef.current) {
+            promptAbortRef.current.abort();
+            promptAbortRef.current = null;
+          }
+          const msg = segmentCount > 0
+            ? `Generation cancelled. ${segmentCount} segment prompt${segmentCount === 1 ? '' : 's'} generated.`
+            : 'Generation cancelled. No segment prompts generated yet.';
+          dispatch({ type: 'SET_ERROR', payload: msg });
+          dispatch({ type: 'SET_STEP', payload: 'error' });
+          return;
+        }
+
+        if (currentStep === 'generating_video' || currentStep === 'processing') {
+          const { klingCancel } = await import('@/utils/api');
+          const currentTaskIds = [...s.activeTaskIds];
+          const cancelPromises = currentTaskIds.map(taskId =>
+            klingCancel(taskId).catch(err => {
+              console.warn(`Failed to cancel task ${taskId}:`, err);
+            })
+          );
+          await Promise.all(cancelPromises);
+          currentTaskIds.forEach(id => {
+            dispatch({ type: 'REMOVE_TASK_ID', payload: id });
+          });
+          dispatch({ type: 'SET_TASK_ID', payload: null });
+          const msg = videoCount > 0
+            ? `Generation cancelled. ${videoCount} video segment${videoCount === 1 ? '' : 's'} generated.`
+            : 'Generation cancelled by user.';
+          dispatch({ type: 'SET_ERROR', payload: msg });
+          dispatch({ type: 'SET_STEP', payload: 'error' });
+          return;
+        }
       } catch (error) {
         console.error('Error cancelling generation:', error);
         dispatch({ type: 'SET_ERROR', payload: 'Failed to cancel generation' });

frontend/src/types/index.ts

@@ -108,12 +108,8 @@ export interface CharacterDescription {
   voice_matching: string;
 }
 
-export interface SynchronizedActions {
-  '0:00-0:02': string;
-  '0:02-0:04': string;
-  '0:04-0:06': string;
-  '0:06-0:08': string;
-}
+/** 4s: 2 keys, 6s: 3 keys, 8s: 4 keys (e.g. "0:00-0:02", "0:02-0:04", ...) */
+export type SynchronizedActions = Record<string, string>;
 
 export interface ActionTimeline {
   dialogue: string;
@@ -188,9 +184,11 @@ export interface GenerationState {
   retryState: {
     failedSegmentIndex: number;
     error: string;
+    attemptCount: number; // Track retry attempts: 0 = first try, 1 = auto-retry, 2+ = manual retry
   } | null;
   activeTaskIds: string[];
   isCancelling: boolean;
+  partialCompletionError: string | null; // Error message for partial completion (some segments succeeded, others failed)
 }
 
 export interface GeneratedVideo {

frontend/src/utils/api.ts

@@ -5,9 +5,16 @@ import type {
   ExtractedFrame,
   LoginRequest,
   LoginResponse,
-  AuthUser
+  AuthUser,
+  GenerationStep
 } from '@/types';
 
+// ==================== RETRY CONSTANTS ====================
+export const RETRY_DELAY_MS = 2000;
+export const MAX_VIDEO_ATTEMPTS = 2;
+/** Max attempts before skipping auto-fix and using flow retry (attemptCount 0, 1 = 2 tries). */
+export const AUTO_FIX_MAX_ATTEMPTS = 3;
+
 const API_BASE = import.meta.env.VITE_API_BASE_URL || 'http://localhost:4000';
 
 // Get auth token from localStorage
@@ -25,6 +32,40 @@ export function removeAuthToken(): void {
   localStorage.removeItem('auth_token');
 }
 
+function getStatusBasedErrorMessage(status: number): string {
+  if (status === 401) return 'Incorrect username or password.';
+  if (status === 403) return 'Access forbidden.';
+  if (status === 404) return 'Resource not found.';
+  if (status >= 500) return 'Server error. Please try again later.';
+  return `Request failed with status ${status}`;
+}
+
+/** Parse error message from a non-ok fetch response (JSON or text). */
+async function parseFetchError(response: Response, defaultMessage: string): Promise<string> {
+  const contentType = response.headers.get('content-type');
+  const isJson = contentType?.includes('application/json');
+  try {
+    if (isJson) {
+      const errorData = await response.json();
+      return errorData.detail || errorData.message || errorData.error ||
+        (typeof errorData === 'string' ? errorData : defaultMessage);
+    }
+    const text = await response.text();
+    return text?.trim() ? text : getStatusBasedErrorMessage(response.status);
+  } catch {
+    return getStatusBasedErrorMessage(response.status);
+  }
+}
+
+/** POST JSON to API with auth. */
+async function apiPostJson<T>(path: string, body: object): Promise<T> {
+  return apiRequest<T>(path, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify(body),
+  });
+}
+
 // Generic API request handler
 async function apiRequest<T>(
   path: string, 
@@ -62,64 +103,16 @@ async function apiRequest<T>(
   });
 
   if (!response.ok) {
-    // If unauthorized, clear token
-    if (response.status === 401) {
-      removeAuthToken();
-    }
-    
-    let errorMessage = `Request failed with status ${response.status}`;
-    
-    // Try to extract error message from response
-    const contentType = response.headers.get('content-type');
-    const isJson = contentType && contentType.includes('application/json');
-    
-    try {
-      if (isJson) {
-      const errorData = await response.json();
-        // Try multiple common error message fields
-        errorMessage = errorData.detail || 
-                       errorData.message || 
-                       errorData.error || 
-                       (typeof errorData === 'string' ? errorData : errorMessage);
-      } else {
-        const text = await response.text();
-        if (text && text.trim()) {
-          errorMessage = text;
-        } else {
-          // Fall back to default message based on status code
-          if (response.status === 401) {
-            errorMessage = 'Incorrect username or password.';
-          } else if (response.status === 403) {
-            errorMessage = 'Access forbidden.';
-          } else if (response.status === 404) {
-            errorMessage = 'Resource not found.';
-          } else if (response.status >= 500) {
-            errorMessage = 'Server error. Please try again later.';
-          }
-        }
-      }
-    } catch (parseError) {
-      // If parsing fails, use status-based default
-      if (response.status === 401) {
-        errorMessage = 'Incorrect username or password.';
-      } else if (response.status === 403) {
-        errorMessage = 'Access forbidden.';
-      } else if (response.status === 404) {
-        errorMessage = 'Resource not found.';
-      } else if (response.status >= 500) {
-        errorMessage = 'Server error. Please try again later.';
-      }
-    }
-    
-    const error = new Error(errorMessage);
+    if (response.status === 401) removeAuthToken();
+    const errorMessage = await parseFetchError(response, `Request failed with status ${response.status}`);
     console.error('API Error:', {
       status: response.status,
       statusText: response.statusText,
       message: errorMessage,
-      url: url,
-      contentType: contentType
+      url,
+      contentType: response.headers.get('content-type'),
     });
-    throw error;
+    throw new Error(errorMessage);
   }
 
   return response.json();
@@ -191,19 +184,11 @@ export interface KlingGenerateResponse {
 }
 
 export async function klingGenerate(params: KlingGenerateParams): Promise<KlingGenerateResponse> {
-  return apiRequest<KlingGenerateResponse>('/api/veo/generate', {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(params),
-  });
+  return apiPostJson<KlingGenerateResponse>('/api/veo/generate', params);
 }
 
 export async function klingExtend(taskId: string, prompt: string | object, seeds?: number, voiceType?: string): Promise<KlingGenerateResponse> {
-  return apiRequest<KlingGenerateResponse>('/api/veo/extend', {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify({ taskId, prompt, seeds, voiceType }),
-  });
+  return apiPostJson<KlingGenerateResponse>('/api/veo/extend', { taskId, prompt, seeds, voiceType });
 }
 
 export async function klingGetStatus(taskId: string): Promise<VideoStatusResponse> {
@@ -237,11 +222,7 @@ export interface ReplicateGenerateResponse {
 }
 
 export async function replicateGenerate(params: ReplicateGenerateParams): Promise<ReplicateGenerateResponse> {
-  return apiRequest<ReplicateGenerateResponse>('/api/replicate/generate', {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(params),
-  });
+  return apiPostJson<ReplicateGenerateResponse>('/api/replicate/generate', params);
 }
 
 export async function replicateGetStatus(predictionId: string): Promise<VideoStatusResponse> {
@@ -274,24 +255,124 @@ export async function waitForReplicateVideo(
 
 // ==================== PROMPT GENERATION ====================
 
-export async function generatePrompts(formData: FormData): Promise<SegmentsPayload> {
-  const response = await fetch(`${API_BASE}/api/generate-prompts`, {
+// Stream event types
+export interface StreamEvent {
+  event: 'start' | 'segment' | 'complete' | 'error';
+  [key: string]: any;
+}
+
+export interface StreamStartEvent extends StreamEvent {
+  event: 'start';
+  total_segments: number;
+  model: string;
+}
+
+export interface StreamSegmentEvent extends StreamEvent {
+  event: 'segment';
+  index: number;
+  total: number;
+  progress: number;
+  segment: any;
+}
+
+export interface StreamCompleteEvent extends StreamEvent {
+  event: 'complete';
+  message: string;
+  prompt_id: string;
+  payload: SegmentsPayload;
+}
+
+export interface StreamErrorEvent extends StreamEvent {
+  event: 'error';
+  message: string;
+  error_type: string;
+}
+
+export interface GeneratePromptsStreamingOptions {
+  signal?: AbortSignal;
+}
+
+/**
+ * Generate prompts with streaming - segments arrive in real-time
+ *
+ * @param formData - Form data with script, style, image, etc.
+ * @param onEvent - Callback for each stream event
+ * @param options - Optional { signal } for cancellation
+ * @returns Promise that resolves with complete payload
+ */
+export async function generatePromptsStreaming(
+  formData: FormData,
+  onEvent: (event: StreamEvent) => void,
+  options?: GeneratePromptsStreamingOptions
+): Promise<SegmentsPayload> {
+  const response = await fetch(`${API_BASE}/api/generate-prompts-stream`, {
     method: 'POST',
     body: formData,
+    signal: options?.signal,
   });
-
   if (!response.ok) {
-    let errorMessage = 'Failed to generate prompts';
-    try {
-      const errorData = await response.json();
-      errorMessage = errorData.detail || errorMessage;
-    } catch {
-      // Ignore
+    throw new Error(await parseFetchError(response, 'Failed to generate prompts'));
+  }
+
+  if (!response.body) {
+    throw new Error('No response body');
+  }
+
+  const reader = response.body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+  let finalPayload: SegmentsPayload | null = null;
+
+  try {
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (options?.signal?.aborted) {
+        reader.releaseLock();
+        throw new Error('Generation cancelled by user');
+      }
+
+      // Decode chunk and add to buffer
+      buffer += decoder.decode(value, { stream: true });
+
+      // Split by newlines (NDJSON format)
+      const lines = buffer.split('\n');
+      buffer = lines.pop() || ''; // Keep incomplete line in buffer
+
+      // Process each complete line
+      for (const line of lines) {
+        if (!line.trim()) continue;
+
+        try {
+          const event = JSON.parse(line) as StreamEvent;
+          
+          // Call event callback
+          onEvent(event);
+
+          // Store final payload from complete event
+          if (event.event === 'complete') {
+            finalPayload = (event as StreamCompleteEvent).payload;
+          }
+
+          // If error event, throw
+          if (event.event === 'error') {
+            throw new Error((event as StreamErrorEvent).message);
+          }
+        } catch (parseError) {
+          console.error('Failed to parse stream event:', parseError, 'Line:', line);
+          // Continue processing other events
+        }
+      }
     }
-    throw new Error(errorMessage);
+  } finally {
+    reader.releaseLock();
   }
 
-  return response.json();
+  if (!finalPayload) {
+    throw new Error('Stream completed without final payload');
+  }
+
+  return finalPayload;
 }
 
 export async function refinePromptContinuity(
@@ -310,11 +391,16 @@ export async function refinePromptContinuity(
 
 // ==================== IMAGE UPLOAD ====================
 
-export async function uploadImage(file: File): Promise<{ url: string; filename: string }> {
+/** Use reference: true when uploading a last-frame for continuity (keeps higher quality). */
+export async function uploadImage(
+  file: File,
+  options?: { reference?: boolean }
+): Promise<{ url: string; filename: string }> {
   const formData = new FormData();
   formData.append('file', file);
+  const path = options?.reference ? '/api/upload-image?reference=true' : '/api/upload-image';
 
-  return apiRequest<{ url: string; filename: string }>('/api/upload-image', {
+  return apiRequest<{ url: string; filename: string }>(path, {
     method: 'POST',
     body: formData,
   });
@@ -335,11 +421,7 @@ export interface ExtractFramesResponse {
 }
 
 export async function extractFrames(params: ExtractFramesParams): Promise<ExtractFramesResponse> {
-  return apiRequest<ExtractFramesResponse>('/api/extract-frames', {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(params),
-  });
+  return apiPostJson<ExtractFramesResponse>('/api/extract-frames', params);
 }
 
 // ==================== WHISPER ANALYSIS ====================
@@ -367,11 +449,7 @@ export interface WhisperAnalyzeResponse {
  * This is the optimized flow that combines Whisper analysis and frame extraction.
  */
 export async function whisperAnalyzeAndExtract(params: WhisperAnalyzeParams): Promise<WhisperAnalyzeResponse> {
-  return apiRequest<WhisperAnalyzeResponse>('/api/whisper/analyze-and-extract', {
-    method: 'POST',
-    headers: { 'Content-Type': 'application/json' },
-    body: JSON.stringify(params),
-  });
+  return apiPostJson<WhisperAnalyzeResponse>('/api/whisper/analyze-and-extract', params);
 }
 
 /**
@@ -389,17 +467,10 @@ export async function refinePromptWithContext(
   formData.append('lastFrame', frameFile);
   formData.append('transcribedDialogue', transcribedDialogue);
   formData.append('expectedDialogue', expectedDialogue);
-  
-  const response = await fetch(`${API_BASE}/api/refine-prompt-continuity`, {
+  return apiRequest<{ refined_prompt: object; original_prompt: object }>('/api/refine-prompt-continuity', {
     method: 'POST',
     body: formData,
   });
-  
-  if (!response.ok) {
-    throw new Error(`Failed to refine prompt: ${response.status}`);
-  }
-  
-  return response.json();
 }
 
 /**
@@ -423,15 +494,13 @@ export async function downloadVideo(url: string): Promise<Blob> {
 
 // ==================== UTILITIES ====================
 
-export async function getVideoDuration(file: File): Promise<number> {
+/** Load video from file; caller must revoke object URL when done. */
+function loadVideoFromFile(file: File): Promise<HTMLVideoElement> {
   return new Promise((resolve, reject) => {
     const video = document.createElement('video');
     video.preload = 'metadata';
     video.src = URL.createObjectURL(file);
-    video.onloadedmetadata = () => {
-      URL.revokeObjectURL(video.src);
-      resolve(video.duration);
-    };
+    video.onloadedmetadata = () => resolve(video);
     video.onerror = () => {
       URL.revokeObjectURL(video.src);
       reject(new Error('Failed to load video metadata'));
@@ -439,54 +508,43 @@ export async function getVideoDuration(file: File): Promise<number> {
   });
 }
 
-export async function generateThumbnails(file: File, count: number = 5): Promise<string[]> {
-  return new Promise((resolve, reject) => {
-    const video = document.createElement('video');
-    video.preload = 'metadata';
-    video.src = URL.createObjectURL(file);
-    video.muted = true;
-
-    video.onloadedmetadata = async () => {
-      const duration = video.duration;
-      const thumbnails: string[] = [];
-      const canvas = document.createElement('canvas');
-      const ctx = canvas.getContext('2d');
-
-      if (!ctx) {
-        URL.revokeObjectURL(video.src);
-        reject(new Error('Could not get canvas context'));
-        return;
-      }
-
-      // Use video's actual dimensions for proper aspect ratio
-      // Scale down while maintaining aspect ratio (max 400px on longest side)
-      const maxSize = 400;
-      const videoWidth = video.videoWidth || 1080;
-      const videoHeight = video.videoHeight || 1920;
-      const scale = Math.min(maxSize / videoWidth, maxSize / videoHeight);
-      
-      canvas.width = Math.round(videoWidth * scale);
-      canvas.height = Math.round(videoHeight * scale);
-
-      for (let i = 0; i < count; i++) {
-        const time = (duration / count) * i;
-        video.currentTime = time;
-        await new Promise<void>((res) => {
-          video.onseeked = () => res();
-        });
-        ctx.drawImage(video, 0, 0, canvas.width, canvas.height);
-        thumbnails.push(canvas.toDataURL('image/jpeg', 0.85));
-      }
-
-      URL.revokeObjectURL(video.src);
-      resolve(thumbnails);
-    };
+export async function getVideoDuration(file: File): Promise<number> {
+  const video = await loadVideoFromFile(file);
+  try {
+    return video.duration;
+  } finally {
+    URL.revokeObjectURL(video.src);
+  }
+}
 
-    video.onerror = () => {
-      URL.revokeObjectURL(video.src);
-      reject(new Error('Failed to load video'));
-    };
-  });
+export async function generateThumbnails(file: File, count: number = 5): Promise<string[]> {
+  const video = await loadVideoFromFile(file);
+  video.muted = true;
+  try {
+    const ctx = document.createElement('canvas').getContext('2d');
+    if (!ctx) throw new Error('Could not get canvas context');
+
+    const maxSize = 400;
+    const videoWidth = video.videoWidth || 1080;
+    const videoHeight = video.videoHeight || 1920;
+    const scale = Math.min(maxSize / videoWidth, maxSize / videoHeight);
+    const w = Math.round(videoWidth * scale);
+    const h = Math.round(videoHeight * scale);
+    ctx.canvas.width = w;
+    ctx.canvas.height = h;
+
+    const duration = video.duration;
+    const thumbnails: string[] = [];
+    for (let i = 0; i < count; i++) {
+      video.currentTime = (duration / count) * i;
+      await new Promise<void>((res) => { video.onseeked = () => res(); });
+      ctx.drawImage(video, 0, 0, w, h);
+      thumbnails.push(ctx.canvas.toDataURL('image/jpeg', 0.85));
+    }
+    return thumbnails;
+  } finally {
+    URL.revokeObjectURL(video.src);
+  }
 }
 
 // Wait for video completion using SSE
@@ -543,39 +601,168 @@ export async function generateVideoWithRetry(
   onRetry?: (attempt: number) => void
 ): Promise<string> {
   let lastError: Error | null = null;
-  
-  for (let attempt = 0; attempt < 2; attempt++) {
+
+  for (let attempt = 0; attempt < MAX_VIDEO_ATTEMPTS; attempt++) {
     try {
       if (attempt > 0) {
-        console.log(`🔄 Retrying video generation (attempt ${attempt + 1}/2)...`);
+        console.log(`🔄 Retrying video generation (attempt ${attempt + 1}/${MAX_VIDEO_ATTEMPTS})...`);
         if (onRetry) {
           onRetry(attempt + 1);
         }
       }
-      
+
       const result = await generateFn();
       const videoUrl = await waitForKlingVideo(result.taskId, timeoutMs);
       return videoUrl;
     } catch (error) {
       lastError = error instanceof Error ? error : new Error(String(error));
       console.error(`❌ Video generation attempt ${attempt + 1} failed:`, lastError.message);
-      
-      // If this was the first attempt, retry once
+
       if (attempt === 0) {
-        console.log('⏳ Waiting 2 seconds before retry...');
-        await new Promise(resolve => setTimeout(resolve, 2000)); // Wait 2 seconds before retry
+        console.log(`⏳ Waiting ${RETRY_DELAY_MS / 1000} seconds before retry...`);
+        await new Promise(resolve => setTimeout(resolve, RETRY_DELAY_MS));
         continue;
       }
-      
-      // If both attempts failed, throw the error
+
       throw lastError;
     }
   }
-  
-  // This should never be reached, but TypeScript needs it
+
   throw lastError || new Error('Video generation failed');
 }
 
+/** Outcome of flow-level retry: either trigger retry or state was updated (partial/error). */
+export type FlowRetryOutcome = 'retry' | 'handled';
+
+/** Shared flow-level retry: on cancel show error; on first failure return 'retry'; else show partial or error. */
+export async function handleFlowRetry(options: {
+  attemptCount: number;
+  errorMessage: string;
+  isCancelled: boolean;
+  generatedCount: number;
+  totalCount: number;
+  setError: (s: string) => void;
+  setStep: (s: GenerationStep) => void;
+  setPartialCompletionError: (s: string | null) => void;
+}): Promise<FlowRetryOutcome> {
+  if (options.isCancelled) {
+    options.setError('Generation cancelled by user');
+    options.setStep('error');
+    return 'handled';
+  }
+  if (options.attemptCount === 0) {
+    await new Promise(resolve => setTimeout(resolve, RETRY_DELAY_MS));
+    return 'retry';
+  }
+  if (options.generatedCount > 0) {
+    options.setPartialCompletionError(
+      `Generation stopped at segment ${options.generatedCount + 1} of ${options.totalCount}. Reason: ${options.errorMessage}`
+    );
+    options.setStep('completed');
+  } else {
+    options.setError(options.errorMessage);
+    options.setStep('error');
+  }
+  return 'handled';
+}
+
+// ==================== CONTENT VALIDATION ====================
+
+export interface ContentValidationRequest {
+  script: string;
+}
+
+export interface ContentValidationResponse {
+  is_valid: boolean;
+  warnings: string[];
+  guidance?: {
+    avoid_public_figures: string[];
+    avoid_copyrighted: string[];
+    avoid_sensitive: string[];
+    best_practices: string[];
+  } | null;
+}
+
+/**
+ * Validate script content before generation to catch potential issues early
+ * Checks for public figures, copyrighted content, and other policy violations
+ */
+export async function validateContent(script: string): Promise<ContentValidationResponse> {
+  return apiPostJson<ContentValidationResponse>('/api/validate-content', { script });
+}
+
+/**
+ * Get content policy guidance
+ */
+export async function getContentGuidance() {
+  return apiRequest('/api/content-guidance');
+}
+
+// ==================== PROMPT SAFETY ====================
+
+export interface SafetyFixRequest {
+  segment: any;  // VeoSegment
+  error_message: string;
+  attempt_count?: number;
+}
+
+export interface SafetyFixResponse {
+  success: boolean;
+  fixed_segment: any | null;
+  changes_made: string | null;
+  error: string | null;
+}
+
+/**
+ * Automatically fix an unsafe prompt using AI
+ * Detects content that triggered safety filters and modifies it to be compliant
+ */
+export async function fixUnsafePrompt(request: SafetyFixRequest): Promise<SafetyFixResponse> {
+  return apiPostJson<SafetyFixResponse>('/api/safety/fix-unsafe-prompt', request);
+}
+
+/**
+ * Check if error is a Veo 3.1 safety/content policy violation
+ * Based on official Veo 3.1 API documentation
+ * 
+ * Official error types:
+ * - PUBLIC_ERROR_MINOR: Generic internal error (wait and retry)
+ * - Support codes (8-digit): Specific safety categories
+ * - "Flagged for containing..." errors: Public figures, unsafe content
+ */
+export function isUnsafeSegmentError(errorMessage: string): boolean {
+  const upperError = errorMessage.toUpperCase();
+  
+  // Official Veo 3.1 safety patterns from documentation
+  const safetyKeywords = [
+    'UNSAFE',
+    'CONTENT_POLICY',
+    'MODERATION',
+    'INAPPROPRIATE',
+    'VIOLATION',
+    'PROHIBITED',
+    'SAFETY',
+    'BLOCKED',
+    
+    // Public figures (MOST COMMON!)
+    'PROMINENT PUBLIC FIGURE',
+    'PUBLIC FIGURE',
+    'CELEBRITY',
+    'POLITICIAN',
+    'FLAGGED FOR CONTAINING',
+    'PROMINENT PUBLIC',
+  ];
+  
+  // Check for safety keywords
+  const hasKeyword = safetyKeywords.some(keyword => upperError.includes(keyword));
+  
+  // Check for 8-digit support code (indicates safety filter)
+  // Official Veo 3.1 uses support codes for safety categories
+  const hasSupportCode = /\b\d{8}\b/.test(errorMessage);
+  
+  return hasKeyword || hasSupportCode;
+}
+
 // ==================== VIDEO MERGE/EXPORT ====================
 
 export interface ClipMetadata {
@@ -605,18 +792,9 @@ export async function mergeVideos(
     method: 'POST',
     body: formData,
   });
-  
   if (!response.ok) {
-    let errorMessage = 'Failed to merge videos';
-    try {
-      const errorData = await response.json();
-      errorMessage = errorData.detail || errorMessage;
-    } catch {
-      // Ignore JSON parse errors
-    }
-    throw new Error(errorMessage);
+    throw new Error(await parseFetchError(response, 'Failed to merge videos'));
   }
-  
   return response.blob();
 }
 

frontend/tailwind.config.js

@@ -69,6 +69,7 @@ export default {
         'pulse-glow': 'pulse-glow 2s ease-in-out infinite',
         'shimmer': 'shimmer 2s linear infinite',
         'spin-slow': 'spin 3s linear infinite',
+        'fade-in': 'fadeIn 0.3s ease-in',
       },
       keyframes: {
         float: {
@@ -83,6 +84,10 @@ export default {
           '0%': { backgroundPosition: '-200% 0' },
           '100%': { backgroundPosition: '200% 0' },
         },
+        fadeIn: {
+          '0%': { opacity: '0', transform: 'translateY(10px)' },
+          '100%': { opacity: '1', transform: 'translateY(0)' },
+        },
       },
     },
   },

main.py

@@ -20,7 +20,8 @@ from api.video_export import router as export_router
 from api.replicate_service import router as replicate_router
 from api.whisper_service import router as whisper_router
 from api.auth import router as auth_router
-from api.pricing import router as pricing_router
+from api.prompt_safety import router as safety_router
+from api.prompt_validator import validate_prompt_content, get_content_guidance
 from utils.storage import cleanup_old_files
 
 # Load environment variables
@@ -100,7 +101,30 @@ app.include_router(prompt_router, prefix="/api")
 app.include_router(export_router, prefix="/api")
 app.include_router(replicate_router, prefix="/api")
 app.include_router(whisper_router, prefix="/api")
-app.include_router(pricing_router, prefix="/api")
+app.include_router(safety_router, prefix="/api/safety")
+
+# Content validation endpoints
+@app.post("/api/validate-content")
+async def validate_content_endpoint(request: dict):
+    """
+    Validate script content before generation to catch potential issues early.
+    Returns warnings about public figures, copyrighted content, etc.
+    """
+    script = request.get("script", "")
+    is_valid, warnings = validate_prompt_content(script)
+    
+    return {
+        "is_valid": is_valid,
+        "warnings": warnings,
+        "guidance": get_content_guidance() if not is_valid else None
+    }
+
+
+@app.get("/api/content-guidance")
+async def content_guidance_endpoint():
+    """Get guidance on content policy compliance"""
+    return get_content_guidance()
+
 
 # Health check endpoints (must be before catch-all route)
 @app.get("/health")
@@ -121,9 +145,10 @@ async def health_check():
 
 # Serve static files (frontend) in production
 frontend_dist_path = os.path.join(os.getcwd(), "frontend", "dist")
-if os.path.exists(frontend_dist_path):
-    # Serve static files
-    app.mount("/assets", StaticFiles(directory=os.path.join(frontend_dist_path, "assets")), name="assets")
+frontend_assets_path = os.path.join(frontend_dist_path, "assets")
+if os.path.exists(frontend_dist_path) and os.path.isdir(frontend_assets_path):
+    # Serve static files (assets must exist; avoid crash when watcher has cleared dist)
+    app.mount("/assets", StaticFiles(directory=frontend_assets_path), name="assets")
     
     # Root endpoint - serve frontend or API info
     @app.get("/")

run-dev.sh

@@ -0,0 +1,39 @@
+#!/bin/bash
+# Run backend + frontend build watcher so frontend auto-rebuilds on change (no manual npm run build).
+
+set -e
+cd "$(dirname "$0")"
+
+if [ ! -d "venv" ]; then
+  echo "❌ venv not found. Run: bash setup.sh"
+  exit 1
+fi
+source venv/bin/activate
+
+# Build frontend once, then start watcher in background
+echo "📦 Building frontend once..."
+(cd frontend && npm run build)
+echo "👀 Starting frontend build watcher (rebuilds on file change)..."
+(cd frontend && npm run build:watch) &
+WATCHER_PID=$!
+trap "kill $WATCHER_PID 2>/dev/null" EXIT
+
+# Wait for dist/assets so Python doesn't start while watcher cleared the dir
+echo "⏳ Waiting for frontend build to be ready..."
+i=0
+while [ $i -lt 30 ]; do
+  if [ -d "frontend/dist/assets" ] && [ -n "$(ls frontend/dist/assets 2>/dev/null)" ]; then
+    break
+  fi
+  sleep 1
+  i=$((i + 1))
+done
+if [ ! -d "frontend/dist/assets" ] || [ -z "$(ls frontend/dist/assets 2>/dev/null)" ]; then
+  echo "❌ frontend/dist/assets not ready after 30s. Check frontend build."
+  exit 1
+fi
+
+echo "🚀 Starting backend at http://localhost:4000"
+echo "   Edit frontend files → auto-rebuild → refresh browser"
+echo ""
+python main.py

standalone_video_creator.py

@@ -789,9 +789,9 @@ async def main():
             # Replicate key will be checked when needed
             pass
         
-        # Generate structured prompts using GPT-4o
+        # Generate structured prompts using GPT-5.2
         print_header("GENERATING VIDEO PROMPTS")
-        print_status("🤖 Using GPT-4o to generate structured prompts...")
+        print_status("🤖 Using GPT-5.2 to generate structured prompts...")
         
         # Read reference image
         with open(config['image_path'], 'rb') as f:

utils/prompt_cache.py

@@ -0,0 +1,201 @@
+"""
+Prompt Cache System
+Saves generated prompts temporarily for reuse and editing
+"""
+
+import json
+import os
+from datetime import datetime
+from typing import Dict, List, Optional, Any
+from pathlib import Path
+
+# Storage directory for cached prompts
+CACHE_DIR = Path("storage/prompt_cache")
+CACHE_DIR.mkdir(parents=True, exist_ok=True)
+
+# In-memory cache for quick access
+_prompt_cache: Dict[str, Dict[str, Any]] = {}
+
+
+def save_prompt(
+    prompt_id: str,
+    payload: Dict[str, Any],
+    metadata: Optional[Dict[str, Any]] = None
+) -> str:
+    """
+    Save a generated prompt to cache
+    
+    Args:
+        prompt_id: Unique identifier for the prompt
+        payload: The segments payload
+        metadata: Optional metadata (script, style, etc.)
+    
+    Returns:
+        The prompt_id
+    """
+    cache_entry = {
+        "prompt_id": prompt_id,
+        "payload": payload,
+        "metadata": metadata or {},
+        "created_at": datetime.now().isoformat(),
+        "updated_at": datetime.now().isoformat()
+    }
+    
+    # Save to in-memory cache
+    _prompt_cache[prompt_id] = cache_entry
+    
+    # Save to disk for persistence
+    cache_file = CACHE_DIR / f"{prompt_id}.json"
+    with open(cache_file, 'w') as f:
+        json.dump(cache_entry, f, indent=2)
+    
+    print(f"💾 Saved prompt to cache: {prompt_id}")
+    return prompt_id
+
+
+def get_prompt(prompt_id: str) -> Optional[Dict[str, Any]]:
+    """
+    Retrieve a cached prompt
+    
+    Args:
+        prompt_id: The prompt identifier
+    
+    Returns:
+        The cached prompt entry or None
+    """
+    # Check in-memory cache first
+    if prompt_id in _prompt_cache:
+        return _prompt_cache[prompt_id]
+    
+    # Check disk cache
+    cache_file = CACHE_DIR / f"{prompt_id}.json"
+    if cache_file.exists():
+        with open(cache_file, 'r') as f:
+            cache_entry = json.load(f)
+            _prompt_cache[prompt_id] = cache_entry
+            return cache_entry
+    
+    return None
+
+
+def update_prompt(
+    prompt_id: str,
+    payload: Optional[Dict[str, Any]] = None,
+    metadata: Optional[Dict[str, Any]] = None
+) -> Optional[Dict[str, Any]]:
+    """
+    Update an existing cached prompt
+    
+    Args:
+        prompt_id: The prompt identifier
+        payload: Updated payload (optional)
+        metadata: Updated metadata (optional)
+    
+    Returns:
+        The updated cache entry or None if not found
+    """
+    cache_entry = get_prompt(prompt_id)
+    if not cache_entry:
+        return None
+    
+    # Update fields
+    if payload is not None:
+        cache_entry["payload"] = payload
+    if metadata is not None:
+        cache_entry["metadata"].update(metadata)
+    
+    cache_entry["updated_at"] = datetime.now().isoformat()
+    
+    # Save updated entry
+    _prompt_cache[prompt_id] = cache_entry
+    cache_file = CACHE_DIR / f"{prompt_id}.json"
+    with open(cache_file, 'w') as f:
+        json.dump(cache_entry, f, indent=2)
+    
+    print(f"✏️  Updated prompt in cache: {prompt_id}")
+    return cache_entry
+
+
+def list_prompts(limit: int = 50) -> List[Dict[str, Any]]:
+    """
+    List all cached prompts (most recent first)
+    
+    Args:
+        limit: Maximum number of prompts to return
+    
+    Returns:
+        List of cached prompts
+    """
+    # Load all from disk if in-memory cache is empty
+    if not _prompt_cache:
+        for cache_file in CACHE_DIR.glob("*.json"):
+            try:
+                with open(cache_file, 'r') as f:
+                    cache_entry = json.load(f)
+                    _prompt_cache[cache_entry["prompt_id"]] = cache_entry
+            except Exception as e:
+                print(f"⚠️  Error loading {cache_file}: {e}")
+    
+    # Sort by updated_at (most recent first)
+    prompts = sorted(
+        _prompt_cache.values(),
+        key=lambda x: x.get("updated_at", ""),
+        reverse=True
+    )
+    
+    return prompts[:limit]
+
+
+def delete_prompt(prompt_id: str) -> bool:
+    """
+    Delete a cached prompt
+    
+    Args:
+        prompt_id: The prompt identifier
+    
+    Returns:
+        True if deleted, False if not found
+    """
+    # Remove from in-memory cache
+    if prompt_id in _prompt_cache:
+        del _prompt_cache[prompt_id]
+    
+    # Remove from disk
+    cache_file = CACHE_DIR / f"{prompt_id}.json"
+    if cache_file.exists():
+        cache_file.unlink()
+        print(f"🗑️  Deleted prompt from cache: {prompt_id}")
+        return True
+    
+    return False
+
+
+def cleanup_old_prompts(max_age_days: int = 7):
+    """
+    Clean up prompts older than specified days
+    
+    Args:
+        max_age_days: Maximum age in days
+    """
+    from datetime import timedelta
+    
+    cutoff = datetime.now() - timedelta(days=max_age_days)
+    deleted = 0
+    
+    for cache_file in CACHE_DIR.glob("*.json"):
+        try:
+            with open(cache_file, 'r') as f:
+                cache_entry = json.load(f)
+                created_at = datetime.fromisoformat(cache_entry["created_at"])
+                
+                if created_at < cutoff:
+                    cache_file.unlink()
+                    prompt_id = cache_entry["prompt_id"]
+                    if prompt_id in _prompt_cache:
+                        del _prompt_cache[prompt_id]
+                    deleted += 1
+        except Exception as e:
+            print(f"⚠️  Error cleaning up {cache_file}: {e}")
+    
+    if deleted > 0:
+        print(f"🧹 Cleaned up {deleted} old prompts")

utils/prompt_generator.py

@@ -3,6 +3,7 @@ Advanced Prompt Generator using GPT-4o
 Structured JSON generation with strict validation
 """
 
+import json
 import re
 import base64
 from typing import List, Optional, Dict, Any
@@ -99,21 +100,190 @@ class SegmentsPayload(BaseModel):
     segments: List[Segment]
 
 
+# Veo supports 4, 6, or 8 second segments. Each duration has fixed sync keys (2-second blocks).
+SEGMENT_DURATION_SECONDS = (4, 6, 8)
+DURATION_SYNC_KEYS = {
+    4: ("00:00-00:04", ["0:00-0:02", "0:02-0:04"]),
+    6: ("00:00-00:06", ["0:00-0:02", "0:02-0:04", "0:04-0:06"]),
+    8: ("00:00-00:08", ["0:00-0:02", "0:02-0:04", "0:04-0:06", "0:06-0:08"]),
+}
+
+
+def get_duration_string(seconds: int) -> str:
+    """Return Veo duration string for segment length, e.g. '00:00-00:08'."""
+    if seconds not in DURATION_SYNC_KEYS:
+        raise ValueError(f"Segment duration must be one of {SEGMENT_DURATION_SECONDS}, got {seconds}")
+    return DURATION_SYNC_KEYS[seconds][0]
+
+
+def get_sync_keys_for_duration(seconds: int) -> List[str]:
+    """Return required synchronized_actions keys for the given segment duration."""
+    if seconds not in DURATION_SYNC_KEYS:
+        raise ValueError(f"Segment duration must be one of {SEGMENT_DURATION_SECONDS}, got {seconds}")
+    return list(DURATION_SYNC_KEYS[seconds][1])
+
+
+def _flatten_sync_value(v: Any) -> str:
+    """If v is a dict (e.g. {action, camera_movement, audio}), return a single string; else str(v)."""
+    if isinstance(v, dict):
+        for key in ("action", "on_screen_action", "audio", "audio_notes"):
+            if key in v and isinstance(v[key], str) and v[key].strip():
+                return v[key].strip()
+        for val in v.values():
+            if isinstance(val, str) and val.strip():
+                return val.strip()
+        return "Subject in frame, natural delivery."
+    return (v or "Subject in frame, natural delivery.").strip() if isinstance(v, str) else "Subject in frame, natural delivery."
+
+
+def normalize_segment_for_api(
+    segment: Dict[str, Any],
+    segment_text: str,
+    required_sync_keys: List[str],
+    duration_str: str,
+) -> Dict[str, Any]:
+    """
+    Ensure segment matches API contract: action_timeline.dialogue present,
+    synchronized_actions flat (key -> string), segment_info only allowed fields.
+    """
+    segment = dict(segment)
+    at = segment.setdefault("action_timeline", {})
+    at = dict(at)
+
+    # 1. Ensure dialogue at action_timeline.dialogue (required by video APIs)
+    dialogue = at.get("dialogue") or (segment.get("segment_info") or {}).get("dialogue") or (segment.get("segment_info") or {}).get("dialogue_exact")
+    if not (dialogue and isinstance(dialogue, str) and dialogue.strip()):
+        dialogue = segment_text.strip()
+    at["dialogue"] = dialogue
+
+    # 2. Flatten synchronized_actions: only required keys, values must be strings
+    sync_raw = at.get("synchronized_actions") or {}
+    # GPT sometimes puts time keys at top level of action_timeline (e.g. "0:00-0:02": {...})
+    for key in required_sync_keys:
+        if key not in sync_raw and key in at and isinstance(at[key], (dict, str)):
+            sync_raw[key] = at[key]
+    flat_sync = {}
+    for k in required_sync_keys:
+        flat_sync[k] = _flatten_sync_value(sync_raw.get(k))
+    at["synchronized_actions"] = flat_sync
+
+    # Remove any time-range keys from action_timeline that are not "synchronized_actions" (cleanup)
+    for key in list(at.keys()):
+        if key in required_sync_keys and key != "synchronized_actions":
+            at.pop(key, None)
+    segment["action_timeline"] = at
+
+    # 3. segment_info: only segment_number, total_segments, duration, location, continuity_markers
+    si = segment.get("segment_info") or {}
+    default_markers = {
+        "start_position": "",
+        "end_position": "",
+        "start_expression": "",
+        "end_expression": "",
+        "start_gesture": "",
+        "end_gesture": "",
+        "location_status": "Unchanged.",
+    }
+    if isinstance(si.get("continuity_markers"), dict):
+        default_markers.update(si["continuity_markers"])
+    allowed_si = {
+        "segment_number": si.get("segment_number", 1),
+        "total_segments": si.get("total_segments", 1),
+        "duration": duration_str,
+        "location": si.get("location") or "Same as previous segment.",
+        "continuity_markers": default_markers,
+    }
+    segment["segment_info"] = allowed_si
+
+    return segment
+
+
+class SegmentPlanItem(BaseModel):
+    """One segment in the AI-decided plan: duration and dialogue."""
+    duration_seconds: int  # 4, 6, or 8
+    dialogue: str
+
+
+class SegmentPlan(BaseModel):
+    """AI-generated plan: how to split the script into segments with chosen durations."""
+    segments: List[SegmentPlanItem]
+
+
+async def generate_segment_plan_ai(
+    script: str,
+    style: str = "professional",
+    allowed_durations: Optional[List[int]] = None,
+    model: str = "gpt-5.2",
+    api_key: Optional[str] = None,
+) -> List[Dict[str, Any]]:
+    """
+    Let AI decide how many segments to create and which duration (4, 6, or 8 sec) each gets.
+    Returns list of {"duration_seconds": int, "dialogue": str}.
+    """
+    client = OpenAI(api_key=api_key or os.getenv("OPENAI_API_KEY"))
+    allowed = allowed_durations or [4, 6, 8]
+    allowed = [d for d in allowed if d in SEGMENT_DURATION_SECONDS]
+    if not allowed:
+        allowed = [4, 6, 8]
+    allowed_str = ", ".join(str(d) for d in sorted(allowed))
+
+    user_prompt = f"""You are a video script editor. Your goal is to use as FEW segments as possible so the script becomes ready in fewer videos (faster and cost-optimal).
+
+RULES:
+- MINIMIZE the total number of segments. Prefer LONGER segments (8s first, then 6s, use 4s only when necessary).
+- Use ONLY these durations (seconds): {allowed_str}.
+- Assign each part of the script to exactly one segment. No overlap. No repeated text. Cover the entire script.
+- Prefer 8-second segments: pack ~18–22 words per 8s segment (~2.2–2.8 words/sec). Use 6s (~14–17 words) or 4s (~8–11 words) only when a natural break is too short for 8s.
+- Prefer natural break points (sentence boundaries, clauses) but prioritize FEWER segments over perfect phrasing—combine short sentences into one 8s segment when reasonable.
+
+SCRIPT:
+\"\"\"{script.strip()}\"\"\"
+
+STYLE CONTEXT: {style}
+
+Output a JSON object with a single key "segments", which is an array of objects. Each object has:
+- "duration_seconds": number (only {allowed_str})
+- "dialogue": string (the exact text for that segment, no quotes/formatting changes)
+
+Example format:
+{{"segments": [{{"duration_seconds": 6, "dialogue": "Hello and welcome."}}, {{"duration_seconds": 8, "dialogue": "Today we will cover three main points."}}]}}
+
+Return ONLY valid JSON, no markdown."""
+
+    response = client.chat.completions.create(
+        model=model,
+        messages=[
+            {"role": "system", "content": "You output only valid JSON. No explanation, no markdown."},
+            {"role": "user", "content": user_prompt},
+        ],
+        response_format={"type": "json_object"},
+    )
+    text = response.choices[0].message.content or "{}"
+    data = json.loads(text)
+    raw = data.get("segments", [])
+    out = []
+    for i, item in enumerate(raw):
+        d = item.get("duration_seconds", 8)
+        if d not in SEGMENT_DURATION_SECONDS:
+            d = 8
+        if d not in allowed:
+            d = allowed[0]
+        out.append({"duration_seconds": d, "dialogue": (item.get("dialogue") or "").strip()})
+    return out
+
+
+# Higher words_per_second = fewer segments = faster + cost-optimal (fewer videos to generate).
+DEFAULT_WORDS_PER_SECOND = 2.5
+
+
 def split_script_into_segments(
     script: str,
     seconds_per_segment: int = 8,
-    words_per_second: float = 2.2
+    words_per_second: float = DEFAULT_WORDS_PER_SECOND
 ) -> List[str]:
     """
-    Split script into segments based on timing
-    
-    Args:
-        script: Full script text
-        seconds_per_segment: Target duration per segment
-        words_per_second: Speaking rate (adjust for VO tempo)
-    
-    Returns:
-        List of script segments
+    Split script into segments based on timing.
+    Uses a higher default words_per_second to minimize segment count (fewer videos, faster, cheaper).
     """
     sentences = re.split(r'(?<=[.!?])\s+', script.strip())
     sentences = [s.strip() for s in sentences if s.strip()]
@@ -166,6 +336,40 @@ You are a STRICT production-grade JSON generator for Veo 3 video prompts.
 
 ⚠️ CRITICAL: Your output will be VALIDATED. ANY field under minimum word count will be REJECTED.
 
+═══════════════════════════════════════════════════════════
+🚨 CONTENT POLICY - MANDATORY COMPLIANCE 🚨
+═══════════════════════════════════════════════════════════
+
+YOU MUST AVOID ALL OF THE FOLLOWING IN YOUR GENERATED PROMPTS:
+
+❌ NO REAL PEOPLE:
+- NO politicians (Trump, Biden, Modi, Putin, etc.)
+- NO celebrities (Taylor Swift, Beyoncé, Kardashians, etc.)
+- NO athletes (LeBron, Ronaldo, Messi, etc.)
+- NO tech CEOs (Elon Musk, Bezos, Zuckerberg, Gates, etc.)
+- NO public figures of any kind
+→ USE: "a business executive", "a singer", "an athlete", "a tech entrepreneur"
+
+❌ NO COPYRIGHTED CONTENT:
+- NO brand names (Nike, Apple, Starbucks, McDonald's, Tesla, etc.)
+- NO characters (Spider-Man, Batman, Mickey Mouse, etc.)
+- NO trademarked terms
+→ USE: "athletic shoes", "tech company", "coffee shop", "a superhero"
+
+❌ NO SENSITIVE CONTENT:
+- NO violence, blood, gore, weapons
+- NO explicit, sexual, or nude content
+- NO hate speech or discriminatory language
+- NO illegal activities or dangerous behavior
+
+✅ INSTEAD, USE:
+- Generic roles: "a professional", "an entrepreneur", "a performer"
+- Generic descriptions: "athletic footwear", "smartphone", "sports car"
+- Safe, brand-neutral language
+- Family-friendly content only
+
+⚠️ If the script contains any violations, describe the character/scene generically WITHOUT using specific names or brands.
+
 ═══════════════════════════════════════════════════════════
 🚨 CRITICAL: CHARACTER MUST MATCH REFERENCE IMAGE EXACTLY 🚨
 ═══════════════════════════════════════════════════════════
@@ -302,19 +506,21 @@ def _word_count(text: str) -> int:
     return len(re.findall(r"\b\w+\b", text or ""))
 
 
+def _duration_string_to_seconds(duration_str: str) -> Optional[int]:
+    """Map Veo duration string to seconds (4, 6, or 8)."""
+    for sec, (dstr, _) in DURATION_SYNC_KEYS.items():
+        if dstr == duration_str:
+            return sec
+    return None
+
+
 def validate_segments_payload(
     payload: Dict[str, Any],
     expected_segments: int
 ) -> List[str]:
     """
-    Validate the generated payload against strict rules
-    
-    Args:
-        payload: Generated payload
-        expected_segments: Expected number of segments
-    
-    Returns:
-        List of validation errors (empty if valid)
+    Validate the generated payload against strict rules.
+    Supports variable segment durations (4, 6, or 8 seconds).
     """
     errors: List[str] = []
     segs = payload.get("segments", [])
@@ -322,26 +528,32 @@ def validate_segments_payload(
     if len(segs) != expected_segments:
         errors.append(f"Expected {expected_segments} segments, got {len(segs)}.")
     
-    required_sync_keys = {"0:00-0:02", "0:02-0:04", "0:04-0:06", "0:06-0:08"}
     physical_blocks, clothing_blocks, environment_blocks = [], [], []
     
     for i, seg in enumerate(segs, start=1):
-        # Check segment info
         si = seg.get("segment_info", {})
-        if si.get("duration") != "00:00-00:08":
-            errors.append(f"Segment {i}: duration must be 00:00-00:08.")
+        duration_str = si.get("duration", "")
+        duration_sec = _duration_string_to_seconds(duration_str)
+        if duration_sec is None:
+            errors.append(
+                f"Segment {i}: duration must be one of "
+                f"{[DURATION_SYNC_KEYS[s][0] for s in SEGMENT_DURATION_SECONDS]}, got {duration_str!r}."
+            )
+            required_sync_keys = set(get_sync_keys_for_duration(8))
+        else:
+            required_sync_keys = set(get_sync_keys_for_duration(duration_sec))
+        
         if si.get("total_segments") != expected_segments:
             errors.append(
                 f"Segment {i}: total_segments should be {expected_segments}, "
                 f"got {si.get('total_segments')}."
             )
         
-        # Check synchronized actions keys
         sync = seg.get("action_timeline", {}).get("synchronized_actions", {})
         if set(sync.keys()) != required_sync_keys:
             errors.append(
                 f"Segment {i}: synchronized_actions must have keys "
-                f"{sorted(required_sync_keys)}."
+                f"{sorted(required_sync_keys)} for duration {duration_str}."
             )
         
         # Word-count checks
@@ -381,10 +593,105 @@ def validate_segments_payload(
     return errors
 
 
+def _build_payload_summary_for_ai(payload: Dict[str, Any], max_chars_per_field: int = 400) -> str:
+    """Build a compact summary of the payload for AI validation (stay within context limits)."""
+    def _excerpt(s: str, limit: int) -> str:
+        s = (s or "").strip()
+        if len(s) <= limit:
+            return s
+        return s[:limit] + "..."
+    segs = payload.get("segments", [])
+    parts = []
+    for i, seg in enumerate(segs, start=1):
+        dialogue = (seg.get("action_timeline") or {}).get("dialogue", "")
+        physical = _excerpt((seg.get("character_description") or {}).get("physical") or "", max_chars_per_field)
+        environment = _excerpt((seg.get("scene_continuity") or {}).get("environment") or "", max_chars_per_field)
+        parts.append(
+            f"Segment {i}:\n  dialogue: {dialogue!r}\n  physical (excerpt): {physical}\n  environment (excerpt): {environment}"
+        )
+    return "\n\n".join(parts)
+
+
+def validate_segments_payload_with_ai(
+    payload: Dict[str, Any],
+    script: Optional[str] = None,
+    model: str = "gpt-4o-mini",
+    api_key: Optional[str] = None,
+) -> Dict[str, Any]:
+    """
+    Run rule-based validation, then optional AI review for content policy and consistency.
+    
+    Returns:
+        {
+            "valid": bool (schema checks passed),
+            "schema_errors": list[str],
+            "ai_checked": bool,
+            "ai_valid": bool | None (None if AI not run),
+            "ai_warnings": list[str],
+            "ai_suggestions": list[str],
+        }
+    """
+    expected = len(payload.get("segments", []))
+    schema_errors = validate_segments_payload(payload, expected)
+    result = {
+        "valid": len(schema_errors) == 0,
+        "schema_errors": schema_errors,
+        "ai_checked": False,
+        "ai_valid": None,
+        "ai_warnings": [],
+        "ai_suggestions": [],
+    }
+    if expected == 0:
+        return result
+
+    client = OpenAI(api_key=api_key or os.getenv("OPENAI_API_KEY"))
+    if not client.api_key:
+        return result
+
+    summary = _build_payload_summary_for_ai(payload)
+    prompt = f"""You are a video prompt quality reviewer. Review this segments payload summary for:
+
+1. CONTENT POLICY: No real people (politicians, celebrities, athletes, CEOs), no brand names, no copyrighted characters, no violence/explicit/discriminatory content. Flag any violations.
+2. CONSISTENCY: Character (physical) and environment should be the same across segments for visual continuity. Note if they seem to change.
+3. DIALOGUE: Each segment's dialogue should be distinct (no overlap) and flow in order. Note any issues.
+
+Payload summary:
+{summary}
+"""
+    if script:
+        prompt += f"\nOriginal script (for reference):\n{script[:2000]}"
+
+    prompt += """
+
+Respond with a JSON object only:
+{
+  "valid": true or false,
+  "warnings": ["list of specific issues found, or empty if none"],
+  "suggestions": ["list of short improvement suggestions, or empty if none"]
+}
+"""
+
+    try:
+        response = client.chat.completions.create(
+            model=model,
+            messages=[{"role": "user", "content": prompt}],
+            response_format={"type": "json_object"},
+        )
+        raw = response.choices[0].message.content or "{}"
+        data = json.loads(raw)
+        result["ai_checked"] = True
+        result["ai_valid"] = data.get("valid", True)
+        result["ai_warnings"] = data.get("warnings") or []
+        result["ai_suggestions"] = data.get("suggestions") or []
+    except Exception as e:
+        result["ai_warnings"] = [f"AI validation could not run: {str(e)}"]
+    return result
+
+
 def generate_segments_payload(
     inputs: VeoInputs,
     image_bytes: Optional[bytes] = None,
-    model: str = "gpt-4o",
+    model: str = "gpt-5.2",
     api_key: Optional[str] = None
 ) -> Dict[str, Any]:
     """
@@ -492,3 +799,280 @@ def generate_segments_payload(
     # ALWAYS return payload (even with warnings)
     return payload
 
+
+def build_single_segment_prompt(
+    inputs: VeoInputs,
+    segment_text: str,
+    segment_index: int,
+    total_segments: int,
+    reference_character: Optional[Dict[str, Any]] = None,
+    reference_scene: Optional[Dict[str, Any]] = None,
+    segment_duration_seconds: int = 8,
+) -> str:
+    """
+    Build prompt for generating a SINGLE segment
+    
+    Args:
+        inputs: Video generation inputs
+        segment_text: The dialogue for this specific segment
+        segment_index: Index of this segment (0-based)
+        total_segments: Total number of segments
+        reference_character: Character description from first segment (for consistency)
+        reference_scene: Scene description from first segment (for consistency)
+    
+    Returns:
+        Formatted prompt string for single segment
+    """
+    knobs = inputs.model_dump()
+    segment_number = segment_index + 1
+    
+    # Build character consistency section
+    char_consistency = ""
+    if reference_character:
+        char_consistency = f"""
+═══════════════════════════════════════════════════════════
+🔒 CHARACTER CONSISTENCY (MANDATORY)
+═══════════════════════════════════════════════════════════
+
+You MUST use these EXACT character descriptions (copy-paste from Segment 1):
+
+physical (COPY EXACTLY):
+\"\"\"{reference_character.get('physical', '')}\"\"\"
+
+clothing (COPY EXACTLY):
+\"\"\"{reference_character.get('clothing', '')}\"\"\"
+
+⚠️ DO NOT modify these descriptions in any way - they must be IDENTICAL!
+"""
+    else:
+        char_consistency = f"""
+═══════════════════════════════════════════════════════════
+🚨 CHARACTER FROM REFERENCE IMAGE (SEGMENT 1)
+═══════════════════════════════════════════════════════════
+
+A REFERENCE IMAGE IS PROVIDED. Analyze it carefully and describe:
+- EXACT hair color, style, and length
+- EXACT eye color and facial features  
+- EXACT skin tone and age appearance
+- EXACT clothing (color, pattern, style)
+- Any distinctive features (freckles, facial hair, glasses, etc.)
+
+This description will be reused for ALL segments to ensure visual consistency.
+"""
+    
+    # Build scene consistency section
+    scene_consistency = ""
+    if reference_scene:
+        scene_consistency = f"""
+═════════════════���═════════════════════════════════════════
+🔒 SCENE CONSISTENCY (MANDATORY)
+═══════════════════════════════════════════════════════════
+
+You MUST use these EXACT scene descriptions (copy-paste from Segment 1):
+
+environment (COPY EXACTLY):
+\"\"\"{reference_scene.get('environment', '')}\"\"\"
+
+lighting_state (COPY EXACTLY):
+\"\"\"{reference_scene.get('lighting_state', '')}\"\"\"
+
+props_in_frame (COPY EXACTLY):
+\"\"\"{reference_scene.get('props_in_frame', '')}\"\"\"
+
+background_elements (COPY EXACTLY):
+\"\"\"{reference_scene.get('background_elements', '')}\"\"\"
+
+⚠️ DO NOT modify these descriptions in any way - they must be IDENTICAL!
+"""
+    
+    prompt = f"""
+You are a STRICT production-grade JSON generator for Veo 3 video prompts.
+
+⚠️ CRITICAL: Your output will be VALIDATED. ANY field under minimum word count will be REJECTED.
+
+═══════════════════════════════════════════════════════════
+🚨 CONTENT POLICY - MANDATORY COMPLIANCE 🚨
+═══════════════════════════════════════════════════════════
+
+YOU MUST AVOID ALL OF THE FOLLOWING:
+❌ NO real people names (politicians, celebrities, athletes, tech CEOs)
+❌ NO brand names (Nike, Apple, Tesla, Starbucks, etc.)
+❌ NO copyrighted characters (Spider-Man, Batman, etc.)
+❌ NO sensitive content (violence, explicit, hate speech)
+
+✅ USE: Generic roles ("a professional", "athletic shoes", "a smartphone")
+
+Generating: Segment {segment_number} of {total_segments}
+
+{char_consistency}
+
+{scene_consistency}
+
+═══════════════════════════════════════════════════════════
+MANDATORY WORD COUNT REQUIREMENTS - WILL BE VALIDATED
+═══════════════════════════════════════════════════════════
+
+character_description.physical: MINIMUM 150 WORDS {'(COPY from above)' if reference_character else '(from reference image)'}
+character_description.clothing: MINIMUM 100 WORDS {'(COPY from above)' if reference_character else '(from reference image)'}
+character_description.current_state: MINIMUM 50 WORDS (segment-specific)
+character_description.voice_matching: MINIMUM 50 WORDS (segment-specific)
+
+scene_continuity.environment: MINIMUM 150 WORDS {'(COPY from above)' if reference_scene else '(create detailed description)'}
+scene_continuity.camera_position: MINIMUM 50 WORDS
+scene_continuity.lighting_state: MINIMUM 40 WORDS {'(COPY from above)' if reference_scene else ''}
+scene_continuity.props_in_frame: MINIMUM 40 WORDS {'(COPY from above)' if reference_scene else ''}
+scene_continuity.background_elements: MINIMUM 40 WORDS {'(COPY from above)' if reference_scene else ''}
+
+action_timeline.micro_expressions: MINIMUM 40 WORDS
+
+═══════════════════════════════════════════════════════════
+SEGMENT {segment_number} DETAILS
+═══════════════════════════════════════════════════════════
+
+Dialogue for this segment (EXACT - do not modify):
+\"\"\"{segment_text}\"\"\"
+
+🚨 SCHEMA RULES (validation will fail otherwise):
+- segment_info: Include ONLY segment_number, total_segments, duration, location, continuity_markers. Do NOT put dialogue, style_settings, or content_constraints inside segment_info.
+- action_timeline: MUST have a top-level "dialogue" field set to the EXACT dialogue above (the quoted segment text). Video APIs read action_timeline.dialogue for this segment's lines.
+- action_timeline.synchronized_actions: Must be a FLAT object. Each key (e.g. "0:00-0:02") must map to a SINGLE string (e.g. "Subject in frame, begins speaking."). Do NOT use nested objects like {{ "action": "...", "camera_movement": "..." }} under time keys.
+
+Duration: "{get_duration_string(segment_duration_seconds)}"
+Segment number: {segment_number}
+Total segments: {total_segments}
+Synchronized actions keys (flat string values only): {", ".join(get_sync_keys_for_duration(segment_duration_seconds))}
+
+STYLE SETTINGS:
+{knobs}
+
+🚨 CRITICAL: NO BLUR TRANSITIONS 🚨
+- Segment starts SHARP and CLEAR at 0:00
+- camera_movement describes movement from an already-focused state
+- NO fade-in, NO blur, NO gradual focus at segment start
+
+OUTPUT FORMAT:
+Return ONLY valid JSON for this single segment (no markdown, no code blocks):
+{{
+  "segment_info": {{ "segment_number", "total_segments", "duration", "location", "continuity_markers" only }},
+  "character_description": {{ ... }},
+  "scene_continuity": {{ ... }},
+  "action_timeline": {{ "dialogue": "<exact segment dialogue>", "synchronized_actions": {{ "0:00-0:02": "string", ... }}, "micro_expressions", "breathing_rhythm", "location_transition", "continuity_checkpoint" }}
+}}
+"""
+    
+    return prompt
+
+
+async def generate_single_segment(
+    inputs: VeoInputs,
+    segment_text: str,
+    segment_index: int,
+    total_segments: int,
+    image_bytes: Optional[bytes] = None,
+    reference_character: Optional[Dict[str, Any]] = None,
+    reference_scene: Optional[Dict[str, Any]] = None,
+    segment_duration_seconds: int = 8,
+    model: str = "gpt-5.2",
+    api_key: Optional[str] = None
+) -> Dict[str, Any]:
+    """
+    Generate a SINGLE segment using GPT-5.2
+    
+    Args:
+        inputs: Video generation inputs
+        segment_text: Dialogue for this segment
+        segment_index: Index of this segment (0-based)
+        total_segments: Total number of segments
+        image_bytes: Reference image (only needed for first segment)
+        reference_character: Character description to reuse (from segment 1)
+        reference_scene: Scene description to reuse (from segment 1)
+        model: OpenAI model to use
+        api_key: OpenAI API key
+    
+    Returns:
+        Single segment dictionary
+    """
+    # Initialize OpenAI client
+    client = OpenAI(api_key=api_key or os.getenv('OPENAI_API_KEY'))
+    
+    # Build prompt for this specific segment
+    user_prompt = build_single_segment_prompt(
+        inputs=inputs,
+        segment_text=segment_text,
+        segment_index=segment_index,
+        total_segments=total_segments,
+        reference_character=reference_character,
+        reference_scene=reference_scene,
+        segment_duration_seconds=segment_duration_seconds,
+    )
+    
+    # Prepare messages
+    system_content = "You are a precise JSON-only generator that must satisfy a strict schema."
+    
+    messages = [
+        {
+            "role": "system",
+            "content": system_content
+        },
+        {
+            "role": "user",
+            "content": []
+        }
+    ]
+    
+    # Add text prompt
+    messages[1]["content"].append({
+        "type": "text",
+        "text": user_prompt
+    })
+    
+    # Add image only for first segment (character reference)
+    if image_bytes and segment_index == 0:
+        encoded_image = base64.b64encode(image_bytes).decode("utf-8")
+        messages[1]["content"].append({
+            "type": "image_url",
+            "image_url": {
+                "url": f"data:image/jpeg;base64,{encoded_image}"
+            }
+        })
+    
+    required_keys = get_sync_keys_for_duration(segment_duration_seconds)
+    duration_str = get_duration_string(segment_duration_seconds)
+    
+    # For 8s we use strict Segment schema; for 4s/6s we use JSON mode (variable sync keys)
+    if segment_duration_seconds == 8:
+        response = client.beta.chat.completions.parse(
+            model=model,
+            response_format=Segment,
+            messages=messages,
+        )
+        segment = response.choices[0].message.parsed.model_dump(by_alias=True)
+    else:
+        response = client.chat.completions.create(
+            model=model,
+            messages=messages,
+            response_format={"type": "json_object"},
+        )
+        raw = response.choices[0].message.content or "{}"
+        segment = json.loads(raw)
+        # Basic normalize for 4s/6s: duration and sync keys (full normalizer runs below)
+        si = segment.setdefault("segment_info", {})
+        si["duration"] = duration_str
+        si["total_segments"] = total_segments
+        si["segment_number"] = segment_index + 1
+        at = segment.setdefault("action_timeline", {})
+        sync = at.setdefault("synchronized_actions", {})
+        for k in required_keys:
+            if k not in sync:
+                sync[k] = (list(sync.values())[0] if sync else "Subject in frame, natural delivery.")
+        at["synchronized_actions"] = {k: sync[k] for k in required_keys}
+    
+    # Always normalize: ensure action_timeline.dialogue, flat synchronized_actions, clean segment_info
+    segment = normalize_segment_for_api(
+        segment, segment_text, required_keys, duration_str
+    )
+    
+    print(f"✅ Generated segment {segment_index + 1}/{total_segments} ({segment_duration_seconds}s)")
+    
+    return segment
+