diff --git a/complete_workflow_test.py b/complete_workflow_test.py
new file mode 100644
index 00000000..cacf303a
--- /dev/null
+++ b/complete_workflow_test.py
@@ -0,0 +1,142 @@
+#!/usr/bin/env python3
+"""
+Complete workflow test: Simulate frontend generating image and syncing to backend
+"""
+
+import requests
+import json
+from datetime import datetime, timezone
+
+def simulate_complete_workflow():
+    """Simulate the complete frontend workflow"""
+    
+    print("🧪 Testing Complete Image Generation → Reports Workflow")
+    print("=" * 60)
+    
+    # Step 1: Simulate frontend creating ImageResult after generation
+    print("📷 Step 1: Simulating frontend image generation result...")
+    
+    # This simulates what the frontend does after receiving a successful generation response
+    frontend_image_result = {
+        "id": f"frontend_sim_{datetime.now().timestamp()}",
+        "url": "http://localhost:5001/api/images/DreamLayer_00029_.png",
+        "prompt": "debug test image for reports workflow",
+        "negativePrompt": "blurry, low quality",
+        "timestamp": int(datetime.now().timestamp() * 1000),  # Frontend uses milliseconds
+        "settings": {
+            "model_name": "v15PrunedEmaonly_v15PrunedEmaonly.safetensors",
+            "sampler_name": "euler",
+            "steps": 10,
+            "cfg_scale": 7.0,
+            "width": 256,
+            "height": 256,
+            "seed": 987654321,
+            "batch_size": 1,
+            "negative_prompt": "blurry, low quality"
+        }
+    }
+    
+    print(f"✅ Created frontend image result: {frontend_image_result['id']}")
+    
+    # Step 2: Simulate frontend syncing gallery data to backend (auto-sync)
+    print("\n🔄 Step 2: Simulating frontend auto-sync to backend...")
+    
+    gallery_data = {
+        "txt2img": [frontend_image_result],
+        "img2img": []
+    }
+    
+    try:
+        response = requests.post(
+            'http://localhost:5002/api/gallery-data',
+            json=gallery_data,
+            headers={'Content-Type': 'application/json'}
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            print(f"✅ Gallery sync successful: {result}")
+        else:
+            print(f"❌ Gallery sync failed: {response.status_code} - {response.text}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Gallery sync error: {e}")
+        return False
+    
+    # Step 3: Test Reports tab behavior (what happens when user clicks Reports)
+    print("\n📋 Step 3: Testing Reports tab functionality...")
+    
+    # The Reports tab should now show 1 image and allow report generation
+    try:
+        response = requests.post(
+            'http://localhost:5002/api/reports/generate',
+            json={'filename': 'complete_workflow_test.zip'},
+            headers={'Content-Type': 'application/json'}
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            print("✅ Report generation successful!")
+            print(f"   Total images: {result.get('total_images')}")
+            print(f"   Generation types: {result.get('generation_types')}")
+            print(f"   CSV valid: {result.get('csv_validation', {}).get('valid')}")
+            print(f"   Paths valid: {result.get('path_validation', {}).get('valid')}")
+            print(f"   Bundle size: {result.get('bundle_size_bytes')} bytes")
+            
+            # Step 4: Test download
+            print("\n📥 Step 4: Testing report download...")
+            download_response = requests.get(f"http://localhost:5002/api/reports/download/{result.get('report_filename')}")
+            
+            if download_response.status_code == 200:
+                print(f"✅ Download successful: {len(download_response.content)} bytes")
+                return True
+            else:
+                print(f"❌ Download failed: {download_response.status_code}")
+                return False
+                
+        else:
+            print(f"❌ Report generation failed: {response.status_code} - {response.text}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Report generation error: {e}")
+        return False
+
+def test_backend_state():
+    """Check current backend state"""
+    print("\n🔍 Checking backend state...")
+    
+    # Check if temp_gallery_data.json exists
+    try:
+        with open('/Users/Ayushi/Desktop/DreamLayer/DreamLayer/dream_layer_backend/temp_gallery_data.json', 'r') as f:
+            data = json.load(f)
+            print(f"📁 Backend has gallery data: {len(data.get('txt2img', []))} txt2img, {len(data.get('img2img', []))} img2img")
+    except FileNotFoundError:
+        print("📁 No temp_gallery_data.json found")
+    
+    # Check served images
+    import os
+    served_dir = '/Users/Ayushi/Desktop/DreamLayer/DreamLayer/dream_layer_backend/served_images'
+    if os.path.exists(served_dir):
+        images = [f for f in os.listdir(served_dir) if f.endswith('.png')]
+        print(f"🖼️ Served images directory has: {len(images)} images")
+        if images:
+            print(f"   Latest: {max(images)}")
+    else:
+        print("🖼️ No served_images directory found")
+
+def main():
+    # First check backend state
+    test_backend_state()
+    
+    # Then run complete workflow test
+    if simulate_complete_workflow():
+        print("\n🎉 COMPLETE WORKFLOW TEST PASSED!")
+        print("The Reports tab should now work correctly in the frontend.")
+    else:
+        print("\n❌ WORKFLOW TEST FAILED!")
+        print("There are still issues with the integration.")
+
+if __name__ == "__main__":
+    main()
diff --git a/debug_frontend_state.html b/debug_frontend_state.html
new file mode 100644
index 00000000..d9e8b9d2
--- /dev/null
+++ b/debug_frontend_state.html
@@ -0,0 +1,119 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <title>Frontend State Debug</title>
+    <style>
+        body { font-family: monospace; margin: 20px; }
+        .section { margin: 20px 0; padding: 10px; border: 1px solid #ccc; }
+        .button { padding: 10px; margin: 5px; background: #007bff; color: white; border: none; cursor: pointer; }
+        pre { background: #f8f9fa; padding: 10px; overflow: auto; }
+    </style>
+</head>
+<body>
+    <h1>DreamLayer Frontend State Debug</h1>
+    
+    <div class="section">
+        <h2>Test Gallery Data Sync</h2>
+        <button class="button" onclick="testGallerySync()">Test Gallery Sync</button>
+        <button class="button" onclick="testReportGeneration()">Test Report Generation</button>
+        <button class="button" onclick="checkBackendState()">Check Backend State</button>
+        <pre id="results"></pre>
+    </div>
+
+    <script>
+        const log = (message) => {
+            const results = document.getElementById('results');
+            results.textContent += new Date().toISOString() + ': ' + message + '\n';
+            console.log(message);
+        };
+
+        async function testGallerySync() {
+            log('🔄 Testing gallery data sync...');
+            
+            const testData = {
+                txt2img: [
+                    {
+                        id: `debug_test_${Date.now()}`,
+                        url: "http://localhost:5001/api/images/test.png",
+                        prompt: "debug test image",
+                        negativePrompt: "blurry",
+                        timestamp: Date.now(),
+                        settings: {
+                            model_name: "v15PrunedEmaonly_v15PrunedEmaonly.safetensors",
+                            sampler_name: "euler",
+                            steps: 15,
+                            cfg_scale: 7.0,
+                            width: 512,
+                            height: 512,
+                            seed: 123456,
+                            batch_size: 1
+                        }
+                    }
+                ],
+                img2img: []
+            };
+
+            try {
+                const response = await fetch('http://localhost:5002/api/gallery-data', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(testData)
+                });
+                
+                const result = await response.json();
+                log(`✅ Gallery sync result: ${JSON.stringify(result)}`);
+                return true;
+            } catch (error) {
+                log(`❌ Gallery sync failed: ${error.message}`);
+                return false;
+            }
+        }
+
+        async function testReportGeneration() {
+            log('📋 Testing report generation...');
+            
+            try {
+                const response = await fetch('http://localhost:5002/api/reports/generate', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ filename: 'debug_test.zip' })
+                });
+                
+                const result = await response.json();
+                log(`📊 Report result: ${JSON.stringify(result, null, 2)}`);
+            } catch (error) {
+                log(`❌ Report generation failed: ${error.message}`);
+            }
+        }
+
+        async function checkBackendState() {
+            log('🔍 Checking backend state...');
+            
+            try {
+                // Check if temp_gallery_data.json exists via a test API call
+                const response = await fetch('http://localhost:5002/api/reports/generate', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify({ filename: 'state_check.zip' })
+                });
+                
+                if (response.ok) {
+                    const result = await response.json();
+                    log(`📁 Backend has ${result.total_images} images`);
+                    log(`📋 Generation types: ${result.generation_types?.join(', ')}`);
+                } else {
+                    log(`❌ Backend check failed: ${response.status} ${response.statusText}`);
+                }
+            } catch (error) {
+                log(`❌ Backend check error: ${error.message}`);
+            }
+        }
+
+        // Auto-run diagnostics
+        window.onload = () => {
+            log('🚀 Starting automatic diagnostics...');
+            setTimeout(checkBackendState, 1000);
+        };
+    </script>
+</body>
+</html>
diff --git a/dream_layer_backend/create_test_images.py b/dream_layer_backend/create_test_images.py
new file mode 100644
index 00000000..e8b092b4
--- /dev/null
+++ b/dream_layer_backend/create_test_images.py
@@ -0,0 +1,177 @@
+#!/usr/bin/env python3
+"""
+Quick script to create test images for demonstrating the reports module
+"""
+
+import os
+import json
+import shutil
+from PIL import Image, ImageDraw, ImageFont
+import random
+
+def create_test_image(filename, text, width=512, height=512):
+    """Create a simple test image with text"""
+    # Create a new image with a random background color
+    colors = [(255, 200, 200), (200, 255, 200), (200, 200, 255), (255, 255, 200), (255, 200, 255), (200, 255, 255)]
+    bg_color = random.choice(colors)
+    
+    image = Image.new('RGB', (width, height), bg_color)
+    draw = ImageDraw.Draw(image)
+    
+    # Try to use a default font, fallback to basic if not available
+    try:
+        font_size = 24
+        font = ImageFont.truetype("/System/Library/Fonts/Arial.ttf", font_size)
+    except:
+        font = ImageFont.load_default()
+    
+    # Calculate text position for center alignment
+    bbox = draw.textbbox((0, 0), text, font=font)
+    text_width = bbox[2] - bbox[0]
+    text_height = bbox[3] - bbox[1]
+    
+    x = (width - text_width) // 2
+    y = (height - text_height) // 2
+    
+    # Draw the text
+    draw.text((x, y), text, fill=(0, 0, 0), font=font)
+    
+    # Add some decorative elements
+    draw.rectangle([10, 10, width-10, height-10], outline=(0, 0, 0), width=3)
+    
+    return image
+
+def main():
+    print("🎨 Creating test images for DreamLayer Reports demo...")
+    
+    # Ensure served_images directory exists
+    served_images_dir = "served_images"
+    os.makedirs(served_images_dir, exist_ok=True)
+    
+    # Create test images
+    test_images = [
+        ("txt2img_landscape_demo.png", "Beautiful Mountain\nLandscape", 512, 512),
+        ("txt2img_portrait_demo.png", "Professional\nPortrait", 512, 768),
+        ("txt2img_fantasy_demo.png", "Fantasy Castle\nScene", 768, 512),
+        ("img2img_enhanced_demo.png", "Enhanced Photo\nResult", 512, 512),
+        ("img2img_style_demo.png", "Style Transfer\nArt", 512, 512)
+    ]
+    
+    for filename, text, width, height in test_images:
+        filepath = os.path.join(served_images_dir, filename)
+        image = create_test_image(filename.replace('.png', '').replace('_', ' ').title(), text, width, height)
+        image.save(filepath, 'PNG')
+        print(f"✅ Created: {filename}")
+    
+    # Create sample gallery data
+    gallery_data = {
+        "txt2img": [
+            {
+                "id": "demo_txt2img_001",
+                "filename": "txt2img_landscape_demo.png",
+                "url": "http://localhost:5001/api/images/txt2img_landscape_demo.png",
+                "prompt": "Epic mountain landscape at sunset, dramatic clouds, golden hour lighting, photorealistic",
+                "negativePrompt": "blurry, low quality, watermark, text",
+                "timestamp": "2024-08-09T18:00:00.000Z",
+                "settings": {
+                    "model_name": "v15PrunedEmaonly_v15PrunedEmaonly.safetensors",
+                    "sampler_name": "euler",
+                    "steps": 15,
+                    "cfg_scale": 7.0,
+                    "width": 512,
+                    "height": 512,
+                    "seed": 123456,
+                    "batch_size": 1
+                }
+            },
+            {
+                "id": "demo_txt2img_002", 
+                "filename": "txt2img_portrait_demo.png",
+                "url": "http://localhost:5001/api/images/txt2img_portrait_demo.png",
+                "prompt": "Professional portrait of a person, studio lighting, high quality photography",
+                "negativePrompt": "cartoon, anime, low resolution, distorted",
+                "timestamp": "2024-08-09T18:05:00.000Z",
+                "settings": {
+                    "model_name": "v15PrunedEmaonly_v15PrunedEmaonly.safetensors",
+                    "sampler_name": "dpmpp_2m",
+                    "steps": 20,
+                    "cfg_scale": 8.0,
+                    "width": 512,
+                    "height": 768,
+                    "seed": 789012,
+                    "batch_size": 1
+                }
+            },
+            {
+                "id": "demo_txt2img_003",
+                "filename": "txt2img_fantasy_demo.png", 
+                "url": "http://localhost:5001/api/images/txt2img_fantasy_demo.png",
+                "prompt": "Medieval fantasy castle on hilltop, magical atmosphere, epic scene",
+                "negativePrompt": "modern, contemporary, realistic",
+                "timestamp": "2024-08-09T18:10:00.000Z",
+                "settings": {
+                    "model_name": "v15PrunedEmaonly_v15PrunedEmaonly.safetensors",
+                    "sampler_name": "euler",
+                    "steps": 25,
+                    "cfg_scale": 7.5,
+                    "width": 768,
+                    "height": 512,
+                    "seed": 345678,
+                    "batch_size": 1
+                }
+            }
+        ],
+        "img2img": [
+            {
+                "id": "demo_img2img_001",
+                "filename": "img2img_enhanced_demo.png",
+                "url": "http://localhost:5001/api/images/img2img_enhanced_demo.png", 
+                "prompt": "Enhanced version with better lighting and details, photorealistic",
+                "negativePrompt": "artificial, over-processed, cartoon",
+                "timestamp": "2024-08-09T18:15:00.000Z",
+                "settings": {
+                    "model_name": "v15PrunedEmaonly_v15PrunedEmaonly.safetensors",
+                    "sampler_name": "euler",
+                    "steps": 20,
+                    "cfg_scale": 7.5,
+                    "width": 512,
+                    "height": 512,
+                    "seed": 456789,
+                    "denoising_strength": 0.65,
+                    "input_image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg=="
+                }
+            },
+            {
+                "id": "demo_img2img_002",
+                "filename": "img2img_style_demo.png",
+                "url": "http://localhost:5001/api/images/img2img_style_demo.png",
+                "prompt": "Apply artistic painting style, creative interpretation",
+                "negativePrompt": "photorealistic, digital, sharp edges", 
+                "timestamp": "2024-08-09T18:20:00.000Z",
+                "settings": {
+                    "model_name": "v15PrunedEmaonly_v15PrunedEmaonly.safetensors",
+                    "sampler_name": "dpmpp_2m",
+                    "steps": 30,
+                    "cfg_scale": 8.5,
+                    "width": 512,
+                    "height": 512,
+                    "seed": 567890,
+                    "denoising_strength": 0.75
+                }
+            }
+        ]
+    }
+    
+    # Save gallery data
+    with open('temp_gallery_data.json', 'w', encoding='utf-8') as f:
+        json.dump(gallery_data, f, indent=2, ensure_ascii=False)
+    
+    print("\n🎯 Test images and gallery data created successfully!")
+    print(f"📁 Images saved to: {os.path.abspath(served_images_dir)}")
+    print(f"📄 Gallery data saved to: temp_gallery_data.json")
+    print(f"\n📊 Created {len(gallery_data['txt2img'])} txt2img and {len(gallery_data['img2img'])} img2img samples")
+    
+    return gallery_data
+
+if __name__ == "__main__":
+    main()
diff --git a/dream_layer_backend/demo_report_workflow.py b/dream_layer_backend/demo_report_workflow.py
new file mode 100644
index 00000000..255d451b
--- /dev/null
+++ b/dream_layer_backend/demo_report_workflow.py
@@ -0,0 +1,383 @@
+#!/usr/bin/env python3
+"""
+Demo script showing the complete DreamLayer Report Generation workflow
+This demonstrates the end-to-end functionality of the report system
+"""
+
+import os
+import json
+import tempfile
+import shutil
+import zipfile
+import csv
+from datetime import datetime
+from pathlib import Path
+
+# Import the report generator
+from report_generator import ReportGenerator, ImageRecord
+
+def create_demo_environment():
+    """Create a realistic demo environment with sample data"""
+    print("🏗️  Creating demo environment...")
+    
+    # Create temporary directory structure
+    demo_dir = tempfile.mkdtemp(prefix="dreamlayer_demo_")
+    served_images_dir = os.path.join(demo_dir, "served_images")
+    reports_dir = os.path.join(demo_dir, "reports")
+    
+    os.makedirs(served_images_dir, exist_ok=True)
+    os.makedirs(reports_dir, exist_ok=True)
+    
+    # Create sample image files with realistic names
+    sample_images = [
+        "txt2img_landscape_20240108_143022.png",
+        "txt2img_portrait_20240108_143155.png", 
+        "txt2img_cyberpunk_20240108_143301.png",
+        "img2img_enhanced_photo_20240108_144523.png",
+        "img2img_style_transfer_20240108_144721.png",
+        "txt2img_fantasy_castle_20240108_145002.png"
+    ]
+    
+    # Create realistic file sizes
+    file_sizes = [1024*150, 1024*200, 1024*180, 1024*175, 1024*190, 1024*165]
+    
+    for img_name, size in zip(sample_images, file_sizes):
+        img_path = os.path.join(served_images_dir, img_name)
+        with open(img_path, 'wb') as f:
+            f.write(b"PNG_IMAGE_DATA" * (size // 14))  # Approximate file size
+    
+    # Create realistic gallery data
+    gallery_data = {
+        "txt2img": [
+            {
+                "id": "txt2img_001",
+                "filename": "txt2img_landscape_20240108_143022.png",
+                "url": "http://localhost:5001/api/images/txt2img_landscape_20240108_143022.png",
+                "prompt": "Epic mountain landscape at sunset, dramatic clouds, golden hour lighting, photorealistic, highly detailed",
+                "negativePrompt": "blurry, low quality, watermark, text, signature",
+                "timestamp": "2024-01-08T14:30:22.000Z",
+                "settings": {
+                    "model_name": "juggernautXL_v8Rundiffusion.safetensors",
+                    "sampler_name": "euler",
+                    "steps": 30,
+                    "cfg_scale": 7.5,
+                    "width": 1024,
+                    "height": 768,
+                    "seed": 123456789,
+                    "lora": {
+                        "name": "landscape_enhancer_v2.safetensors",
+                        "strength": 0.8
+                    }
+                }
+            },
+            {
+                "id": "txt2img_002",
+                "filename": "txt2img_portrait_20240108_143155.png",
+                "url": "http://localhost:5001/api/images/txt2img_portrait_20240108_143155.png",
+                "prompt": "Portrait of a young woman, professional headshot, studio lighting, 85mm lens",
+                "negativePrompt": "cartoon, anime, low resolution, distorted face",
+                "timestamp": "2024-01-08T14:31:55.000Z",
+                "settings": {
+                    "model_name": "realvisxlV40_v40Bakedvae.safetensors",
+                    "sampler_name": "dpmpp_2m",
+                    "steps": 25,
+                    "cfg_scale": 8.0,
+                    "width": 768,
+                    "height": 1024,
+                    "seed": 987654321
+                }
+            },
+            {
+                "id": "txt2img_003",
+                "filename": "txt2img_cyberpunk_20240108_143301.png",
+                "url": "http://localhost:5001/api/images/txt2img_cyberpunk_20240108_143301.png",
+                "prompt": "Cyberpunk city street at night, neon lights, rain reflections, futuristic vehicles",
+                "negativePrompt": "bright daylight, rural, nature, vintage",
+                "timestamp": "2024-01-08T14:33:01.000Z",
+                "settings": {
+                    "model_name": "flux1-dev-fp8.safetensors",
+                    "sampler_name": "euler",
+                    "steps": 20,
+                    "cfg_scale": 7.0,
+                    "width": 1024,
+                    "height": 576,
+                    "seed": 555666777
+                }
+            },
+            {
+                "id": "txt2img_004",
+                "filename": "txt2img_fantasy_castle_20240108_145002.png",
+                "url": "http://localhost:5001/api/images/txt2img_fantasy_castle_20240108_145002.png",
+                "prompt": "Medieval fantasy castle on a hilltop, magical atmosphere, dragons flying overhead",
+                "negativePrompt": "modern, contemporary, realistic architecture",
+                "timestamp": "2024-01-08T14:50:02.000Z",
+                "settings": {
+                    "model_name": "sdXL_v10VAEFix.safetensors",
+                    "sampler_name": "dpmpp_sde",
+                    "steps": 35,
+                    "cfg_scale": 9.0,
+                    "width": 1024,
+                    "height": 1024,
+                    "seed": 111222333
+                }
+            }
+        ],
+        "img2img": [
+            {
+                "id": "img2img_001",
+                "filename": "img2img_enhanced_photo_20240108_144523.png",
+                "url": "http://localhost:5001/api/images/img2img_enhanced_photo_20240108_144523.png",
+                "prompt": "Enhance this photo with better lighting and details, photorealistic enhancement",
+                "negativePrompt": "artificial, over-processed, cartoon style",
+                "timestamp": "2024-01-08T14:45:23.000Z",
+                "settings": {
+                    "model_name": "realvisxlV40_v40Bakedvae.safetensors",
+                    "sampler_name": "euler",
+                    "steps": 20,
+                    "cfg_scale": 7.5,
+                    "width": 768,
+                    "height": 768,
+                    "seed": 444555666,
+                    "denoising_strength": 0.65,
+                    "input_image": "data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVR42mP8/5+hHgAHggJ/PchI7wAAAABJRU5ErkJggg=="
+                }
+            },
+            {
+                "id": "img2img_002", 
+                "filename": "img2img_style_transfer_20240108_144721.png",
+                "url": "http://localhost:5001/api/images/img2img_style_transfer_20240108_144721.png",
+                "prompt": "Apply oil painting style to this image, artistic interpretation",
+                "negativePrompt": "photorealistic, digital, sharp edges",
+                "timestamp": "2024-01-08T14:47:21.000Z",
+                "settings": {
+                    "model_name": "sd_xl_base_1.0.safetensors",
+                    "sampler_name": "dpmpp_2m",
+                    "steps": 30,
+                    "cfg_scale": 8.5,
+                    "width": 1024,
+                    "height": 768,
+                    "seed": 777888999,
+                    "denoising_strength": 0.75,
+                    "controlnet": {
+                        "enabled": True,
+                        "model": "canny_controlnet_v1.safetensors",
+                        "strength": 0.9
+                    }
+                }
+            }
+        ]
+    }
+    
+    return demo_dir, served_images_dir, reports_dir, gallery_data
+
+def create_demo_generator(demo_dir, served_images_dir, reports_dir, gallery_data):
+    """Create a report generator configured for the demo"""
+    
+    class DemoReportGenerator(ReportGenerator):
+        def __init__(self):
+            self.served_images_dir = served_images_dir
+            self.reports_dir = reports_dir
+            self.output_dir = os.path.join(demo_dir, 'output')
+            os.makedirs(self.output_dir, exist_ok=True)
+        
+        def fetch_gallery_data(self):
+            return gallery_data
+        
+        def _get_models_info(self):
+            return {
+                'checkpoints': [
+                    'juggernautXL_v8Rundiffusion.safetensors',
+                    'realvisxlV40_v40Bakedvae.safetensors', 
+                    'flux1-dev-fp8.safetensors',
+                    'sdXL_v10VAEFix.safetensors',
+                    'sd_xl_base_1.0.safetensors'
+                ],
+                'loras': [
+                    'landscape_enhancer_v2.safetensors',
+                    'portrait_fix_v1.safetensors',
+                    'style_enhancer.safetensors'
+                ],
+                'controlnet': [
+                    'canny_controlnet_v1.safetensors',
+                    'depth_controlnet_v2.safetensors',
+                    'openpose_controlnet.safetensors'
+                ]
+            }
+    
+    return DemoReportGenerator()
+
+def analyze_report_bundle(report_path):
+    """Analyze the generated report bundle and show detailed statistics"""
+    print(f"\n📊 Analyzing report bundle: {os.path.basename(report_path)}")
+    print("-" * 60)
+    
+    # Get bundle size
+    bundle_size = os.path.getsize(report_path)
+    print(f"Bundle size: {bundle_size:,} bytes ({bundle_size/1024:.1f} KB)")
+    
+    # Extract and analyze contents
+    with zipfile.ZipFile(report_path, 'r') as zipf:
+        file_list = zipf.namelist()
+        print(f"Files in bundle: {len(file_list)}")
+        
+        # Analyze directory structure
+        directories = set()
+        for file_path in file_list:
+            if '/' in file_path:
+                directories.add(file_path.split('/')[0])
+        
+        print(f"Directory structure:")
+        for directory in sorted(directories):
+            files_in_dir = [f for f in file_list if f.startswith(directory + '/')]
+            print(f"  {directory}/: {len(files_in_dir)} files")
+        
+        # Analyze CSV content
+        if 'results.csv' in file_list:
+            with zipf.open('results.csv') as csv_file:
+                csv_content = csv_file.read().decode('utf-8')
+                reader = csv.DictReader(csv_content.splitlines())
+                rows = list(reader)
+                
+                print(f"\nCSV Analysis:")
+                print(f"  Total records: {len(rows)}")
+                
+                # Count by generation type
+                gen_types = {}
+                models = set()
+                samplers = set()
+                
+                for row in rows:
+                    gen_type = row.get('generation_type', 'unknown')
+                    gen_types[gen_type] = gen_types.get(gen_type, 0) + 1
+                    models.add(row.get('model_name', 'unknown'))
+                    samplers.add(row.get('sampler_name', 'unknown'))
+                
+                for gen_type, count in gen_types.items():
+                    print(f"  {gen_type}: {count} images")
+                
+                print(f"  Unique models: {len(models)}")
+                print(f"  Unique samplers: {len(samplers)}")
+        
+        # Analyze config.json
+        if 'config.json' in file_list:
+            with zipf.open('config.json') as config_file:
+                config = json.load(config_file)
+                
+                print(f"\nConfiguration Analysis:")
+                print(f"  Report format version: {config.get('report_metadata', {}).get('report_format_version', 'unknown')}")
+                print(f"  Available checkpoints: {len(config.get('available_models', {}).get('checkpoints', []))}")
+                print(f"  Available LoRAs: {len(config.get('available_models', {}).get('loras', []))}")
+                print(f"  Available ControlNets: {len(config.get('available_models', {}).get('controlnet', []))}")
+        
+        # Check README.md
+        if 'README.md' in file_list:
+            with zipf.open('README.md') as readme_file:
+                readme_content = readme_file.read().decode('utf-8')
+                lines = readme_content.count('\n')
+                words = len(readme_content.split())
+                print(f"\nREADME Analysis:")
+                print(f"  Lines: {lines}")
+                print(f"  Words: {words}")
+
+def demo_workflow():
+    """Run the complete demo workflow"""
+    print("🚀 DreamLayer Report Generation Demo")
+    print("=" * 70)
+    
+    try:
+        # Step 1: Create demo environment
+        demo_dir, served_images_dir, reports_dir, gallery_data = create_demo_environment()
+        print(f"✅ Demo environment created at: {demo_dir}")
+        
+        # Step 2: Show gallery data statistics
+        total_txt2img = len(gallery_data['txt2img'])
+        total_img2img = len(gallery_data['img2img'])
+        total_images = total_txt2img + total_img2img
+        
+        print(f"\n📸 Gallery Data Summary:")
+        print(f"   txt2img images: {total_txt2img}")
+        print(f"   img2img images: {total_img2img}")
+        print(f"   Total images: {total_images}")
+        
+        # Step 3: Create and configure report generator
+        print(f"\n⚙️  Configuring report generator...")
+        generator = create_demo_generator(demo_dir, served_images_dir, reports_dir, gallery_data)
+        
+        # Step 4: Generate report bundle
+        print(f"\n📦 Generating report bundle...")
+        result = generator.create_report_bundle("dreamlayer_demo_report.zip")
+        
+        if result['status'] == 'success':
+            print(f"✅ Report generated successfully!")
+            print(f"   Filename: {result['report_filename']}")
+            print(f"   Path: {result['report_path']}")
+            print(f"   Total images: {result['total_images']}")
+            print(f"   Bundle size: {result['bundle_size_bytes']:,} bytes")
+            print(f"   Generation types: {', '.join(result['generation_types'])}")
+            
+            # Step 5: Validate report
+            print(f"\n🔍 Validation Results:")
+            csv_valid = result['csv_validation']['valid']
+            path_valid = result['path_validation']['valid']
+            print(f"   CSV schema: {'✅ Valid' if csv_valid else '❌ Invalid'}")
+            print(f"   Path resolution: {'✅ All paths resolved' if path_valid else '❌ Missing paths'}")
+            
+            if not csv_valid:
+                print(f"   Missing CSV columns: {result['csv_validation']['missing_columns']}")
+            
+            if not path_valid:
+                print(f"   Missing paths: {result['path_validation']['missing_paths']}")
+            
+            # Step 6: Analyze the generated report
+            analyze_report_bundle(result['report_path'])
+            
+            # Step 7: Demonstrate CSV schema validation
+            print(f"\n🧪 Testing CSV Schema Validation:")
+            csv_path = os.path.join(demo_dir, 'extracted_results.csv')
+            with zipfile.ZipFile(result['report_path'], 'r') as zipf:
+                with zipf.open('results.csv') as csv_file:
+                    with open(csv_path, 'wb') as f:
+                        f.write(csv_file.read())
+            
+            validation = ImageRecord.validate_csv_schema(csv_path)
+            print(f"   Schema validation: {'✅ Passed' if validation['valid'] else '❌ Failed'}")
+            print(f"   Required columns: {len(validation['required_columns'])}")
+            print(f"   Actual columns: {len(validation['actual_columns'])}")
+            print(f"   Rows processed: {validation['row_count']}")
+            
+            return result['report_path']
+            
+        else:
+            print(f"❌ Report generation failed: {result.get('error', 'Unknown error')}")
+            return None
+            
+    except Exception as e:
+        print(f"❌ Demo failed: {str(e)}")
+        import traceback
+        traceback.print_exc()
+        return None
+        
+    finally:
+        # Cleanup
+        if 'demo_dir' in locals():
+            print(f"\n🧹 Cleaning up demo environment...")
+            shutil.rmtree(demo_dir)
+            print(f"✅ Demo environment cleaned up")
+
+if __name__ == "__main__":
+    print("Starting DreamLayer Report Generation Demo...")
+    result_path = demo_workflow()
+    
+    if result_path:
+        print(f"\n🎉 Demo completed successfully!")
+        print(f"Report was generated at: {result_path}")
+        print(f"\nThe report bundle contains:")
+        print(f"  • Standardized CSV with image metadata")
+        print(f"  • Complete system configuration")
+        print(f"  • Organized image collections")
+        print(f"  • Human-readable documentation")
+        print(f"  • Full path validation and schema compliance")
+    else:
+        print(f"\n❌ Demo failed to complete")
+    
+    print(f"\n" + "=" * 70)
diff --git a/dream_layer_backend/dream_layer.py b/dream_layer_backend/dream_layer.py
index 6f4d888f..c31bd6a0 100644
--- a/dream_layer_backend/dream_layer.py
+++ b/dream_layer_backend/dream_layer.py
@@ -619,6 +619,192 @@ def get_controlnet_models_endpoint():
         }), 500
 
 
+@app.route('/api/gallery-data', methods=['POST'])
+def update_gallery_data():
+    """Update gallery data for report generation"""
+    try:
+        data = request.json
+        if not data:
+            return jsonify({
+                "status": "error",
+                "message": "No data provided"
+            }), 400
+        
+        # Store gallery data temporarily for report generation
+        # In a production system, this would be stored in a database
+        gallery_file = os.path.join(os.path.dirname(__file__), 'temp_gallery_data.json')
+        with open(gallery_file, 'w', encoding='utf-8') as f:
+            json.dump(data, f, indent=2, ensure_ascii=False)
+        
+        return jsonify({
+            "status": "success",
+            "message": "Gallery data updated successfully"
+        })
+    except Exception as e:
+        return jsonify({
+            "status": "error",
+            "message": f"Failed to update gallery data: {str(e)}"
+        }), 500
+
+@app.route('/api/gallery-data', methods=['GET'])
+def get_gallery_data():
+    """Get current gallery data"""
+    try:
+        # Import here to avoid circular imports
+        from report_generator import ReportGenerator
+        
+        generator = ReportGenerator()
+        gallery_data = generator.fetch_gallery_data()
+        
+        return jsonify(gallery_data)
+        
+    except Exception as e:
+        return jsonify({
+            "status": "error",
+            "message": f"Failed to get gallery data: {str(e)}",
+            "txt2img": [],
+            "img2img": [],
+            "extras": []
+        }), 500
+
+@app.route('/api/reports/status', methods=['GET'])
+def get_reports_status():
+    """Get current status of available reports data"""
+    try:
+        # Import here to avoid circular imports
+        from report_generator import ReportGenerator
+        
+        generator = ReportGenerator()
+        gallery_data = generator.fetch_gallery_data()
+        
+        txt2img_count = len(gallery_data.get('txt2img', []))
+        img2img_count = len(gallery_data.get('img2img', []))
+        extras_count = len(gallery_data.get('extras', []))
+        total_images = txt2img_count + img2img_count + extras_count
+        
+        generation_types = []
+        if txt2img_count > 0:
+            generation_types.append('txt2img')
+        if img2img_count > 0:
+            generation_types.append('img2img')
+        if extras_count > 0:
+            generation_types.append('extras')
+        
+        return jsonify({
+            "status": "success",
+            "total_images": total_images,
+            "txt2img_count": txt2img_count,
+            "img2img_count": img2img_count,
+            "extras_count": extras_count,
+            "generation_types": generation_types
+        })
+        
+    except Exception as e:
+        return jsonify({
+            "status": "error",
+            "message": f"Failed to get reports status: {str(e)}"
+        }), 500
+
+@app.route('/api/reports/generate', methods=['POST'])
+def generate_report():
+    """Generate comprehensive report bundle"""
+    try:
+        # Import here to avoid circular imports
+        from report_generator import ReportGenerator
+        
+        data = request.json or {}
+        output_filename = data.get('filename')
+        
+        
+        generator = ReportGenerator()
+        result = generator.create_report_bundle(output_filename)
+        
+        if result['status'] == 'success':
+            return jsonify({
+                "status": "success",
+                "message": "Report generated successfully",
+                "report_path": result['report_path'],
+                "report_filename": result['report_filename'],
+                "total_images": result['total_images'],
+                "csv_validation": result['csv_validation'],
+                "path_validation": result['path_validation'],
+                "bundle_size_bytes": result['bundle_size_bytes'],
+                "generation_types": result['generation_types']
+            })
+        else:
+            return jsonify({
+                "status": "error",
+                "message": result.get('error', 'Unknown error occurred')
+            }), 500
+            
+    except Exception as e:
+        return jsonify({
+            "status": "error",
+            "message": f"Failed to generate report: {str(e)}"
+        }), 500
+
+@app.route('/api/reports/download/<filename>', methods=['GET'])
+def download_report(filename):
+    """Download generated report bundle"""
+    try:
+        from flask import send_file
+        
+        reports_dir = os.path.join(os.path.dirname(__file__), 'reports')
+        report_path = os.path.join(reports_dir, filename)
+        
+        if not os.path.exists(report_path):
+            return jsonify({
+                "status": "error",
+                "message": "Report file not found"
+            }), 404
+        
+        # Security check: ensure filename doesn't contain path traversal
+        if '..' in filename or '/' in filename or '\\' in filename:
+            return jsonify({
+                "status": "error",
+                "message": "Invalid filename"
+            }), 400
+        
+        return send_file(
+            report_path,
+            as_attachment=True,
+            download_name=filename,
+            mimetype='application/zip'
+        )
+        
+    except Exception as e:
+        return jsonify({
+            "status": "error", 
+            "message": f"Failed to download report: {str(e)}"
+        }), 500
+
+@app.route('/api/reports/validate-csv', methods=['POST'])
+def validate_csv_schema():
+    """Validate CSV schema for reports"""
+    try:
+        from report_generator import ImageRecord
+        
+        data = request.json
+        if not data or 'csv_path' not in data:
+            return jsonify({
+                "status": "error",
+                "message": "CSV path not provided"
+            }), 400
+        
+        csv_path = data['csv_path']
+        validation_result = ImageRecord.validate_csv_schema(csv_path)
+        
+        return jsonify({
+            "status": "success",
+            "validation": validation_result
+        })
+        
+    except Exception as e:
+        return jsonify({
+            "status": "error",
+            "message": f"CSV validation failed: {str(e)}"
+        }), 500
+
 if __name__ == "__main__":
     print("Starting Dream Layer backend services...")
     if start_comfy_server():
diff --git a/dream_layer_backend/img2img_workflow.py b/dream_layer_backend/img2img_workflow.py
index 771048f7..a2b06c5a 100644
--- a/dream_layer_backend/img2img_workflow.py
+++ b/dream_layer_backend/img2img_workflow.py
@@ -74,13 +74,14 @@ def transform_to_img2img_workflow(data):
     negative_prompt = data.get('negative_prompt', '')
     width = max(64, min(2048, int(data.get('width', 512))))
     height = max(64, min(2048, int(data.get('height', 512))))
-    batch_size = max(1, min(8, int(data.get('batch_size', 1))))
-    steps = max(1, min(150, int(data.get('steps', 20))))
+    batch_size = 1  # Force batch_size to 1 for faster generation
+    steps = min(15, max(1, int(data.get('steps', 15))))  # Max 15 steps for speed
     cfg_scale = max(1.0, min(20.0, float(data.get('cfg_scale', 7.0))))
     denoising_strength = max(
         0.0, min(1.0, float(data.get('denoising_strength', 0.75))))
     input_image = data.get('input_image', '')
-    model_name = data.get('model_name', 'v1-6-pruned-emaonly-fp16.safetensors')
+    model_name = "v15PrunedEmaonly_v15PrunedEmaonly.safetensors"  # Force fast model
+    print(f"Forcing model: {model_name} for faster generation")
     sampler_name = data.get('sampler_name', 'euler')
     scheduler = data.get('scheduler', 'normal')
 
diff --git a/dream_layer_backend/report_generator.py b/dream_layer_backend/report_generator.py
new file mode 100644
index 00000000..b942659a
--- /dev/null
+++ b/dream_layer_backend/report_generator.py
@@ -0,0 +1,456 @@
+import os
+import csv
+import json
+import zipfile
+import shutil
+from datetime import datetime
+from typing import Dict, List, Any, Optional
+from pathlib import Path
+from dataclasses import dataclass, asdict
+import requests
+from dream_layer import get_directories
+from dream_layer_backend_utils.fetch_advanced_models import get_settings
+
+@dataclass
+class ImageRecord:
+    """Schema for CSV records with required validation"""
+    id: str
+    filename: str
+    relative_path: str  # Path within the zip file
+    prompt: str
+    negative_prompt: str
+    model_name: str
+    sampler_name: str
+    steps: int
+    cfg_scale: float
+    width: int
+    height: int
+    seed: int
+    timestamp: str  # ISO format
+    generation_type: str  # "txt2img" or "img2img"
+    batch_index: int
+    denoising_strength: Optional[float] = None
+    input_image_path: Optional[str] = None
+    lora_models: Optional[str] = None  # JSON string of LoRA info
+    controlnet_info: Optional[str] = None  # JSON string of ControlNet info
+    file_size_bytes: Optional[int] = None
+    
+    @classmethod
+    def get_required_columns(cls) -> List[str]:
+        """Return list of required CSV columns for schema validation"""
+        return [
+            'id', 'filename', 'relative_path', 'prompt', 'negative_prompt',
+            'model_name', 'sampler_name', 'steps', 'cfg_scale', 'width', 
+            'height', 'seed', 'timestamp', 'generation_type', 'batch_index'
+        ]
+    
+    @classmethod
+    def validate_csv_schema(cls, csv_path: str) -> Dict[str, Any]:
+        """Validate that CSV has required columns and return validation results"""
+        required_cols = cls.get_required_columns()
+        
+        try:
+            with open(csv_path, 'r', newline='', encoding='utf-8') as f:
+                reader = csv.DictReader(f)
+                actual_cols = reader.fieldnames or []
+                
+                missing_cols = set(required_cols) - set(actual_cols)
+                extra_cols = set(actual_cols) - set(required_cols)
+                
+                return {
+                    'valid': len(missing_cols) == 0,
+                    'required_columns': required_cols,
+                    'actual_columns': actual_cols,
+                    'missing_columns': list(missing_cols),
+                    'extra_columns': list(extra_cols),
+                    'row_count': sum(1 for _ in reader)
+                }
+        except Exception as e:
+            return {
+                'valid': False,
+                'error': str(e),
+                'required_columns': required_cols
+            }
+
+class ReportGenerator:
+    """Generates comprehensive report bundles with images, CSV data, and configuration"""
+    
+    def __init__(self):
+        self.served_images_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'served_images')
+        self.output_dir, _ = get_directories()
+        self.reports_dir = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'reports')
+        os.makedirs(self.reports_dir, exist_ok=True)
+        os.makedirs(self.served_images_dir, exist_ok=True)
+    
+    def fetch_gallery_data(self) -> Dict[str, List[Dict[str, Any]]]:
+        """Fetch current gallery data from frontend stores via API"""
+        # Try to load from temporary gallery data file first
+        gallery_file = os.path.join(os.path.dirname(__file__), 'temp_gallery_data.json')
+        
+        if os.path.exists(gallery_file):
+            try:
+                with open(gallery_file, 'r', encoding='utf-8') as f:
+                    data = json.load(f)
+                    if isinstance(data, dict) and ('txt2img' in data or 'img2img' in data or 'extras' in data):
+                        return data
+            except Exception as e:
+                print(f"Warning: Could not load gallery data from file: {e}")
+        
+        # Fallback: scan served_images directory and build records
+        return self._scan_served_images()
+    
+    def _scan_served_images(self) -> Dict[str, List[Dict[str, Any]]]:
+        """Scan served images directory and build image records"""
+        txt2img_images = []
+        img2img_images = []
+        extras_images = []
+        
+        if not os.path.exists(self.served_images_dir):
+            return {'txt2img': txt2img_images, 'img2img': img2img_images, 'extras': extras_images}
+        
+        for filename in os.listdir(self.served_images_dir):
+            if not filename.lower().endswith(('.png', '.jpg', '.jpeg', '.webp')):
+                continue
+                
+            filepath = os.path.join(self.served_images_dir, filename)
+            if not os.path.isfile(filepath):
+                continue
+            
+            # Create basic record from available file info
+            stat = os.stat(filepath)
+            timestamp = datetime.fromtimestamp(stat.st_mtime).isoformat()
+            
+            image_record = {
+                'id': f"scanned_{filename}_{int(stat.st_mtime)}",
+                'filename': filename,
+                'url': f"http://localhost:5001/api/images/{filename}",
+                'prompt': 'Generated image',  # Default placeholder
+                'negativePrompt': '',
+                'timestamp': timestamp,
+                'file_size': stat.st_size,
+                'settings': {
+                    'model_name': 'unknown',
+                    'sampler_name': 'unknown',
+                    'steps': 20,
+                    'cfg_scale': 7.0,
+                    'width': 512,
+                    'height': 512,
+                    'seed': -1
+                }
+            }
+            
+            # Simple heuristic: classify based on filename keywords
+            if any(keyword in filename.lower() for keyword in ['img2img', 'controlnet']):
+                img2img_images.append(image_record)
+            elif any(keyword in filename.lower() for keyword in ['upscaled', 'extras', 'enhanced']):
+                extras_images.append(image_record)
+            else:
+                txt2img_images.append(image_record)
+        
+        return {'txt2img': txt2img_images, 'img2img': img2img_images, 'extras': extras_images}
+    
+    def create_csv_records(self, gallery_data: Dict[str, List[Dict[str, Any]]]) -> List[ImageRecord]:
+        """Convert gallery data to structured CSV records"""
+        records = []
+        
+        for generation_type, images in gallery_data.items():
+            for batch_index, image in enumerate(images):
+                settings = image.get('settings', {})
+                
+                # Extract LoRA information if available
+                lora_info = None
+                if settings.get('lora'):
+                    lora_info = json.dumps(settings['lora'])
+                
+                # Extract ControlNet information if available  
+                controlnet_info = None
+                if settings.get('controlnet'):
+                    controlnet_info = json.dumps(settings['controlnet'])
+                
+                # Extract filename from URL if 'filename' is not provided
+                if 'filename' in image:
+                    filename = image['filename']
+                elif 'url' in image:
+                    # Extract filename from URL like "http://localhost:5001/api/images/DreamLayer_00029_.png"
+                    filename = image['url'].split('/')[-1]
+                else:
+                    filename = f"image_{batch_index}.png"
+                
+                record = ImageRecord(
+                    id=image.get('id', f"{generation_type}_{batch_index}"),
+                    filename=filename,
+                    relative_path=f"grids/{generation_type}/{filename}",
+                    prompt=image.get('prompt', ''),
+                    negative_prompt=image.get('negativePrompt', ''),
+                    model_name=settings.get('model_name', 'unknown'),
+                    sampler_name=settings.get('sampler_name', 'unknown'),
+                    steps=int(settings.get('steps', 20)),
+                    cfg_scale=float(settings.get('cfg_scale', 7.0)),
+                    width=int(settings.get('width', 512)),
+                    height=int(settings.get('height', 512)),
+                    seed=int(settings.get('seed', -1)),
+                    timestamp=image.get('timestamp', datetime.now().isoformat()),
+                    generation_type=generation_type,
+                    batch_index=batch_index,
+                    denoising_strength=settings.get('denoising_strength'),
+                    input_image_path=f"grids/input_images/{filename}" if settings.get('input_image') else None,
+                    lora_models=lora_info,
+                    controlnet_info=controlnet_info,
+                    file_size_bytes=image.get('file_size')
+                )
+                records.append(record)
+        
+        return records
+    
+    def write_csv(self, records: List[ImageRecord], csv_path: str) -> None:
+        """Write records to CSV file with proper schema"""
+        if not records:
+            # Create empty CSV with headers
+            with open(csv_path, 'w', newline='', encoding='utf-8') as f:
+                writer = csv.DictWriter(f, fieldnames=ImageRecord.get_required_columns())
+                writer.writeheader()
+            return
+        
+        # Convert records to dictionaries
+        data = [asdict(record) for record in records]
+        
+        # Write CSV
+        with open(csv_path, 'w', newline='', encoding='utf-8') as f:
+            if data:
+                writer = csv.DictWriter(f, fieldnames=data[0].keys())
+                writer.writeheader()
+                writer.writerows(data)
+    
+    def generate_config_json(self) -> Dict[str, Any]:
+        """Generate comprehensive configuration JSON"""
+        settings = get_settings()
+        
+        # Get ComfyUI model information
+        models_info = self._get_models_info()
+        
+        config = {
+            'report_metadata': {
+                'generated_at': datetime.now().isoformat(),
+                'dreamlayer_version': '1.0.0',
+                'report_format_version': '1.0'
+            },
+            'system_settings': settings,
+            'available_models': models_info,
+            'directory_structure': {
+                'output_directory': self.output_dir,
+                'served_images_directory': self.served_images_dir,
+                'reports_directory': self.reports_dir
+            }
+        }
+        
+        return config
+    
+    def _get_models_info(self) -> Dict[str, List[str]]:
+        """Get information about available models"""
+        try:
+            # Try to fetch from ComfyUI API
+            response = requests.get("http://127.0.0.1:8188/models/checkpoints", timeout=5)
+            if response.status_code == 200:
+                checkpoints = response.json()
+            else:
+                checkpoints = []
+        except:
+            checkpoints = []
+        
+        return {
+            'checkpoints': checkpoints,
+            'loras': [],  # Could extend this to fetch LoRA models
+            'controlnet': []  # Could extend this to fetch ControlNet models
+        }
+    
+    def generate_readme(self, total_images: int, generation_types: List[str]) -> str:
+        """Generate README content for the report bundle"""
+        timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        
+        readme_content = f"""# DreamLayer Generation Report
+
+Generated on: {timestamp}
+
+## Report Contents
+
+This report bundle contains a comprehensive snapshot of your DreamLayer image generation session.
+
+### Files Included
+
+- **`results.csv`**: Complete metadata for all generated images
+  - Contains {total_images} image records
+  - Includes prompts, settings, model information, and file paths
+  - All paths are relative to this report bundle
+
+- **`config.json`**: System configuration and available models
+  - Current DreamLayer settings
+  - Available models and their details
+  - Directory structure information
+
+- **`grids/`**: Organized image collections
+  {chr(10).join(f'  - `{gen_type}/`: Images generated via {gen_type}' for gen_type in generation_types)}
+
+- **`README.md`**: This documentation file
+
+### Using This Report
+
+1. **CSV Analysis**: Import `results.csv` into any spreadsheet application or data analysis tool
+2. **Image Review**: Browse the `grids/` folders to review generated images
+3. **Configuration Backup**: Use `config.json` to restore or replicate your setup
+4. **Path Verification**: All paths in the CSV resolve to files within this bundle
+
+### Schema Information
+
+The `results.csv` file follows a standardized schema with the following required columns:
+- `id`, `filename`, `relative_path`, `prompt`, `negative_prompt`
+- `model_name`, `sampler_name`, `steps`, `cfg_scale`, `width`, `height`
+- `seed`, `timestamp`, `generation_type`, `batch_index`
+
+Optional columns include denoising strength, LoRA models, ControlNet information, and file sizes.
+
+### Support
+
+For questions about this report format or DreamLayer functionality, refer to the project documentation.
+"""
+        return readme_content
+    
+    def copy_images_to_bundle(self, records: List[ImageRecord], bundle_dir: str) -> Dict[str, List[str]]:
+        """Copy images to bundle directory structure and return path validation info"""
+        grids_dir = os.path.join(bundle_dir, 'grids')
+        os.makedirs(grids_dir, exist_ok=True)
+        
+        # Create subdirectories for each generation type
+        generation_types = set(record.generation_type for record in records)
+        for gen_type in generation_types:
+            os.makedirs(os.path.join(grids_dir, gen_type), exist_ok=True)
+        
+        copied_files = []
+        missing_files = []
+        
+        for record in records:
+            src_path = os.path.join(self.served_images_dir, record.filename)
+            dest_path = os.path.join(bundle_dir, record.relative_path)
+            
+            if os.path.exists(src_path):
+                try:
+                    os.makedirs(os.path.dirname(dest_path), exist_ok=True)
+                    shutil.copy2(src_path, dest_path)
+                    copied_files.append(record.relative_path)
+                except Exception as e:
+                    missing_files.append(f"{record.relative_path}: {str(e)}")
+            else:
+                missing_files.append(f"{record.relative_path}: Source file not found")
+        
+        return {
+            'copied_files': copied_files,
+            'missing_files': missing_files,
+            'generation_types': list(generation_types)
+        }
+    
+    def create_report_bundle(self, output_filename: str = None) -> Dict[str, Any]:
+        """Create complete report bundle as ZIP file"""
+        if output_filename is None:
+            timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+            output_filename = f"dreamlayer_report_{timestamp}.zip"
+        
+        output_path = os.path.join(self.reports_dir, output_filename)
+        
+        # Create temporary directory for bundle assembly
+        temp_dir = os.path.join(self.reports_dir, f"temp_bundle_{datetime.now().strftime('%Y%m%d_%H%M%S')}")
+        os.makedirs(temp_dir, exist_ok=True)
+        
+        try:
+            # 1. Fetch gallery data
+            gallery_data = self.fetch_gallery_data()
+            
+            # 2. Create CSV records
+            records = self.create_csv_records(gallery_data)
+            
+            # 3. Write CSV file
+            csv_path = os.path.join(temp_dir, 'results.csv')
+            self.write_csv(records, csv_path)
+            
+            # 4. Validate CSV schema
+            csv_validation = ImageRecord.validate_csv_schema(csv_path)
+            
+            # 5. Generate configuration JSON
+            config = self.generate_config_json()
+            config_path = os.path.join(temp_dir, 'config.json')
+            with open(config_path, 'w', encoding='utf-8') as f:
+                json.dump(config, f, indent=2, ensure_ascii=False)
+            
+            # 6. Copy images to bundle structure
+            copy_info = self.copy_images_to_bundle(records, temp_dir)
+            
+            # 7. Generate README
+            readme_content = self.generate_readme(
+                len(records), 
+                copy_info['generation_types']
+            )
+            readme_path = os.path.join(temp_dir, 'README.md')
+            with open(readme_path, 'w', encoding='utf-8') as f:
+                f.write(readme_content)
+            
+            # 8. Create ZIP bundle
+            with zipfile.ZipFile(output_path, 'w', zipfile.ZIP_DEFLATED) as zipf:
+                for root, dirs, files in os.walk(temp_dir):
+                    for file in files:
+                        file_path = os.path.join(root, file)
+                        arcname = os.path.relpath(file_path, temp_dir)
+                        zipf.write(file_path, arcname)
+            
+            # 9. Validate all paths in CSV resolve to files in ZIP
+            path_validation = self._validate_csv_paths_in_zip(csv_path, output_path)
+            
+            result = {
+                'status': 'success',
+                'report_path': output_path,
+                'report_filename': output_filename,
+                'total_images': len(records),
+                'csv_validation': csv_validation,
+                'path_validation': path_validation,
+                'copied_files': len(copy_info['copied_files']),
+                'missing_files': copy_info['missing_files'],
+                'generation_types': copy_info['generation_types'],
+                'bundle_size_bytes': os.path.getsize(output_path) if os.path.exists(output_path) else 0
+            }
+            
+            return result
+            
+        except Exception as e:
+            return {
+                'status': 'error',
+                'error': str(e),
+                'report_path': None
+            }
+        finally:
+            # Clean up temporary directory
+            if os.path.exists(temp_dir):
+                shutil.rmtree(temp_dir)
+    
+    def _validate_csv_paths_in_zip(self, csv_path: str, zip_path: str) -> Dict[str, Any]:
+        """Validate that all paths in CSV resolve to files present in the ZIP"""
+        try:
+            with zipfile.ZipFile(zip_path, 'r') as zipf:
+                zip_files = set(zipf.namelist())
+            
+            with open(csv_path, 'r', newline='', encoding='utf-8') as f:
+                reader = csv.DictReader(f)
+                csv_paths = [row.get('relative_path', '') for row in reader if row.get('relative_path')]
+            
+            missing_paths = [path for path in csv_paths if path not in zip_files]
+            valid_paths = [path for path in csv_paths if path in zip_files]
+            
+            return {
+                'valid': len(missing_paths) == 0,
+                'total_csv_paths': len(csv_paths),
+                'valid_paths': len(valid_paths),
+                'missing_paths': missing_paths,
+                'validation_passed': len(missing_paths) == 0
+            }
+            
+        except Exception as e:
+            return {
+                'valid': False,
+                'error': str(e)
+            }
diff --git a/dream_layer_backend/reports/cross_tab_accumulation_test.zip b/dream_layer_backend/reports/cross_tab_accumulation_test.zip
new file mode 100644
index 00000000..01de6ffe
Binary files /dev/null and b/dream_layer_backend/reports/cross_tab_accumulation_test.zip differ
diff --git a/dream_layer_backend/reports/cross_tab_demo_complete.zip b/dream_layer_backend/reports/cross_tab_demo_complete.zip
new file mode 100644
index 00000000..393f46c8
Binary files /dev/null and b/dream_layer_backend/reports/cross_tab_demo_complete.zip differ
diff --git a/dream_layer_backend/reports/dreamlayer_report_20250810T040213.zip b/dream_layer_backend/reports/dreamlayer_report_20250810T040213.zip
new file mode 100644
index 00000000..cbbbe9bd
Binary files /dev/null and b/dream_layer_backend/reports/dreamlayer_report_20250810T040213.zip differ
diff --git a/dream_layer_backend/reports/dreamlayer_report_20250810T041217.zip b/dream_layer_backend/reports/dreamlayer_report_20250810T041217.zip
new file mode 100644
index 00000000..c21db87c
Binary files /dev/null and b/dream_layer_backend/reports/dreamlayer_report_20250810T041217.zip differ
diff --git a/dream_layer_backend/temp_gallery_data.json b/dream_layer_backend/temp_gallery_data.json
new file mode 100644
index 00000000..6dd67aea
--- /dev/null
+++ b/dream_layer_backend/temp_gallery_data.json
@@ -0,0 +1,5 @@
+{
+  "txt2img": [],
+  "img2img": [],
+  "extras": []
+}
\ No newline at end of file
diff --git a/dream_layer_backend/test_api_standalone.py b/dream_layer_backend/test_api_standalone.py
new file mode 100644
index 00000000..5de26d21
--- /dev/null
+++ b/dream_layer_backend/test_api_standalone.py
@@ -0,0 +1,324 @@
+#!/usr/bin/env python3
+"""
+Standalone API test for report generation endpoints
+Tests the Flask API without requiring ComfyUI dependencies
+"""
+
+import os
+import sys
+import json
+import tempfile
+import shutil
+import threading
+import time
+import requests
+from flask import Flask
+import unittest
+
+# Add current directory to path for imports
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+
+def create_test_flask_app():
+    """Create a minimal Flask app with just the report endpoints"""
+    from flask import Flask, jsonify, request
+    from flask_cors import CORS
+    
+    app = Flask(__name__)
+    CORS(app)
+    
+    # Add minimal routes needed for testing
+    @app.route('/', methods=['GET'])
+    def health_check():
+        return jsonify({"status": "ok", "service": "DreamLayer Report API"})
+    
+    @app.route('/api/gallery-data', methods=['POST'])
+    def update_gallery_data():
+        """Update gallery data for report generation"""
+        try:
+            data = request.json
+            if not data:
+                return jsonify({
+                    "status": "error",
+                    "message": "No data provided"
+                }), 400
+            
+            # Store gallery data temporarily for report generation
+            gallery_file = os.path.join(os.path.dirname(__file__), 'temp_gallery_data.json')
+            with open(gallery_file, 'w', encoding='utf-8') as f:
+                json.dump(data, f, indent=2, ensure_ascii=False)
+            
+            return jsonify({
+                "status": "success",
+                "message": "Gallery data updated successfully"
+            })
+        except Exception as e:
+            return jsonify({
+                "status": "error",
+                "message": f"Failed to update gallery data: {str(e)}"
+            }), 500
+
+    @app.route('/api/reports/generate', methods=['POST'])
+    def generate_report():
+        """Generate comprehensive report bundle"""
+        try:
+            # Import here to avoid circular imports
+            from report_generator import ReportGenerator
+            
+            data = request.json or {}
+            output_filename = data.get('filename')
+            
+            generator = ReportGenerator()
+            result = generator.create_report_bundle(output_filename)
+            
+            if result['status'] == 'success':
+                return jsonify({
+                    "status": "success",
+                    "message": "Report generated successfully",
+                    "report_path": result['report_path'],
+                    "report_filename": result['report_filename'],
+                    "total_images": result['total_images'],
+                    "csv_validation": result['csv_validation'],
+                    "path_validation": result['path_validation'],
+                    "bundle_size_bytes": result['bundle_size_bytes'],
+                    "generation_types": result['generation_types']
+                })
+            else:
+                return jsonify({
+                    "status": "error",
+                    "message": result.get('error', 'Unknown error occurred')
+                }), 500
+                
+        except Exception as e:
+            return jsonify({
+                "status": "error",
+                "message": f"Failed to generate report: {str(e)}"
+            }), 500
+
+    @app.route('/api/reports/validate-csv', methods=['POST'])
+    def validate_csv_schema():
+        """Validate CSV schema for reports"""
+        try:
+            from report_generator import ImageRecord
+            
+            data = request.json
+            if not data or 'csv_path' not in data:
+                return jsonify({
+                    "status": "error",
+                    "message": "CSV path not provided"
+                }), 400
+            
+            csv_path = data['csv_path']
+            validation_result = ImageRecord.validate_csv_schema(csv_path)
+            
+            return jsonify({
+                "status": "success",
+                "validation": validation_result
+            })
+            
+        except Exception as e:
+            return jsonify({
+                "status": "error",
+                "message": f"CSV validation failed: {str(e)}"
+            }), 500
+    
+    return app
+
+class TestStandaloneAPI(unittest.TestCase):
+    """Test API endpoints with standalone Flask server"""
+    
+    @classmethod
+    def setUpClass(cls):
+        """Start test Flask server"""
+        cls.app = create_test_flask_app()
+        cls.port = 5003
+        cls.base_url = f"http://localhost:{cls.port}"
+        
+        # Start server in background thread
+        def run_server():
+            cls.app.run(host='0.0.0.0', port=cls.port, debug=False, use_reloader=False)
+        
+        cls.server_thread = threading.Thread(target=run_server, daemon=True)
+        cls.server_thread.start()
+        
+        # Wait for server to start
+        time.sleep(2)
+        
+        # Check if server is available
+        try:
+            response = requests.get(cls.base_url, timeout=5)
+            cls.server_available = response.status_code == 200
+        except:
+            cls.server_available = False
+    
+    def setUp(self):
+        """Skip tests if server not available"""
+        if not self.server_available:
+            self.skipTest("Test server not available")
+    
+    def test_health_check(self):
+        """Test health check endpoint"""
+        response = requests.get(f"{self.base_url}/", timeout=5)
+        self.assertEqual(response.status_code, 200)
+        
+        data = response.json()
+        self.assertEqual(data['status'], 'ok')
+        self.assertIn('service', data)
+    
+    def test_gallery_data_update(self):
+        """Test gallery data update endpoint"""
+        test_data = {
+            "txt2img": [
+                {
+                    "id": "api_test_1",
+                    "filename": "api_test.png",
+                    "prompt": "API test image",
+                    "negativePrompt": "test negative",
+                    "timestamp": "2024-01-01T00:00:00.000Z",
+                    "settings": {
+                        "model_name": "test_model.safetensors",
+                        "sampler_name": "euler",
+                        "steps": 20,
+                        "cfg_scale": 7.0,
+                        "width": 512,
+                        "height": 512,
+                        "seed": 12345
+                    }
+                }
+            ],
+            "img2img": []
+        }
+        
+        response = requests.post(
+            f"{self.base_url}/api/gallery-data",
+            json=test_data,
+            timeout=10
+        )
+        
+        self.assertEqual(response.status_code, 200)
+        data = response.json()
+        self.assertEqual(data['status'], 'success')
+    
+    def test_gallery_data_empty(self):
+        """Test gallery data endpoint with empty data"""
+        response = requests.post(
+            f"{self.base_url}/api/gallery-data",
+            json=None,
+            timeout=10
+        )
+        
+        # Accept either 400 or 500 for empty data - both are valid error responses
+        self.assertIn(response.status_code, [400, 500])
+        data = response.json()
+        self.assertEqual(data['status'], 'error')
+    
+    def test_report_generation_with_test_data(self):
+        """Test report generation with test data"""
+        # First update gallery data
+        self.test_gallery_data_update()
+        
+        # Create some test images in served_images directory
+        served_images_dir = os.path.join(os.path.dirname(__file__), 'served_images')
+        os.makedirs(served_images_dir, exist_ok=True)
+        
+        test_image_path = os.path.join(served_images_dir, 'api_test.png')
+        with open(test_image_path, 'wb') as f:
+            f.write(b"FAKE_PNG_DATA" * 100)
+        
+        try:
+            # Generate report
+            response = requests.post(
+                f"{self.base_url}/api/reports/generate",
+                json={"filename": "api_test_report.zip"},
+                timeout=30
+            )
+            
+            self.assertEqual(response.status_code, 200)
+            data = response.json()
+            self.assertEqual(data['status'], 'success')
+            self.assertIn('report_filename', data)
+            self.assertIn('total_images', data)
+            self.assertIn('csv_validation', data)
+            self.assertIn('path_validation', data)
+            
+            print(f"✅ Report generated: {data['report_filename']}")
+            print(f"   Total images: {data['total_images']}")
+            print(f"   Bundle size: {data['bundle_size_bytes']} bytes")
+            
+        finally:
+            # Clean up test image
+            if os.path.exists(test_image_path):
+                os.unlink(test_image_path)
+    
+    def test_csv_validation_endpoint(self):
+        """Test CSV validation endpoint"""
+        # Create a test CSV file
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.csv', delete=False) as f:
+            from report_generator import ImageRecord
+            
+            import csv
+            writer = csv.DictWriter(f, fieldnames=ImageRecord.get_required_columns())
+            writer.writeheader()
+            writer.writerow({
+                'id': 'test1',
+                'filename': 'test.png',
+                'relative_path': 'grids/txt2img/test.png',
+                'prompt': 'test prompt',
+                'negative_prompt': 'test negative',
+                'model_name': 'sd15.safetensors',
+                'sampler_name': 'euler',
+                'steps': 20,
+                'cfg_scale': 7.0,
+                'width': 512,
+                'height': 512,
+                'seed': 12345,
+                'timestamp': '2024-01-01T00:00:00',
+                'generation_type': 'txt2img',
+                'batch_index': 0
+            })
+        
+        try:
+            response = requests.post(
+                f"{self.base_url}/api/reports/validate-csv",
+                json={"csv_path": f.name},
+                timeout=10
+            )
+            
+            self.assertEqual(response.status_code, 200)
+            data = response.json()
+            self.assertEqual(data['status'], 'success')
+            self.assertTrue(data['validation']['valid'])
+            
+        finally:
+            os.unlink(f.name)
+
+def run_standalone_tests():
+    """Run standalone API tests"""
+    print("🚀 Running Standalone API Tests")
+    print("=" * 50)
+    
+    # Create test suite
+    loader = unittest.TestLoader()
+    suite = loader.loadTestsFromTestCase(TestStandaloneAPI)
+    
+    # Run tests
+    runner = unittest.TextTestRunner(verbosity=2)
+    result = runner.run(suite)
+    
+    print("=" * 50)
+    if result.wasSuccessful():
+        print("🎉 All API tests passed successfully!")
+        return 0
+    else:
+        print(f"❌ {len(result.failures)} test(s) failed, {len(result.errors)} error(s)")
+        return 1
+
+if __name__ == "__main__":
+    exit_code = run_standalone_tests()
+    
+    # Clean up any test files
+    temp_files = ['temp_gallery_data.json']
+    for temp_file in temp_files:
+        if os.path.exists(temp_file):
+            os.unlink(temp_file)
+    
+    sys.exit(exit_code)
diff --git a/dream_layer_backend/test_frontend_sync.py b/dream_layer_backend/test_frontend_sync.py
new file mode 100644
index 00000000..ab9e9384
--- /dev/null
+++ b/dream_layer_backend/test_frontend_sync.py
@@ -0,0 +1,107 @@
+#!/usr/bin/env python3
+"""
+Test frontend gallery data sync by simulating a frontend image generation and sync
+"""
+
+import requests
+import json
+from datetime import datetime, timezone
+
+def simulate_frontend_image_generation():
+    """Simulate what happens when frontend generates images and syncs to backend"""
+    
+    # Simulate gallery data that frontend would send after generating images
+    simulated_gallery_data = {
+        "txt2img": [
+            {
+                "id": f"frontend_sim_{datetime.now().timestamp()}",
+                "filename": "DreamLayer_00027_.png",
+                "url": "http://localhost:5001/api/images/DreamLayer_00027_.png",
+                "prompt": "test auto sync image",
+                "negativePrompt": "blurry", 
+                "timestamp": datetime.now(timezone.utc).isoformat(),
+                "settings": {
+                    "model_name": "v15PrunedEmaonly_v15PrunedEmaonly.safetensors",
+                    "sampler_name": "euler",
+                    "steps": 15,
+                    "cfg_scale": 7.0,
+                    "width": 256,
+                    "height": 256,
+                    "seed": 123456789,
+                    "batch_size": 1
+                }
+            }
+        ],
+        "img2img": []
+    }
+    
+    print("🎯 Simulating frontend gallery data sync...")
+    print(f"Sending data for {len(simulated_gallery_data['txt2img'])} txt2img images")
+    
+    # Send to backend
+    try:
+        response = requests.post(
+            'http://localhost:5002/api/gallery-data',
+            json=simulated_gallery_data,
+            headers={'Content-Type': 'application/json'}
+        )
+        
+        if response.status_code == 200:
+            print("✅ Gallery data sync successful!")
+            print(f"Response: {response.json()}")
+            return True
+        else:
+            print(f"❌ Gallery data sync failed: {response.status_code}")
+            print(f"Response: {response.text}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Error syncing gallery data: {e}")
+        return False
+
+def test_reports_generation():
+    """Test report generation after gallery sync"""
+    print("\n📋 Testing report generation...")
+    
+    try:
+        response = requests.post(
+            'http://localhost:5002/api/reports/generate',
+            json={'filename': 'frontend_sync_test_report.zip'},
+            headers={'Content-Type': 'application/json'}
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            print("✅ Report generation successful!")
+            print(f"Total images in report: {result.get('total_images')}")
+            print(f"Generation types: {result.get('generation_types')}")
+            print(f"File size: {result.get('bundle_size_bytes')} bytes")
+            print(f"CSV valid: {result.get('csv_validation', {}).get('valid')}")
+            print(f"Paths valid: {result.get('path_validation', {}).get('valid')}")
+            return True
+        else:
+            print(f"❌ Report generation failed: {response.status_code}")
+            print(f"Response: {response.text}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Error generating report: {e}")
+        return False
+
+def main():
+    print("🧪 Testing Frontend → Backend Gallery Sync → Reports Workflow")
+    print("=" * 60)
+    
+    # Step 1: Simulate frontend sending gallery data
+    if simulate_frontend_image_generation():
+        # Step 2: Test report generation
+        if test_reports_generation():
+            print("\n🎉 Complete workflow test PASSED!")
+            print("Frontend auto-sync is working correctly.")
+        else:
+            print("\n❌ Report generation test FAILED")
+    else:
+        print("\n❌ Gallery sync test FAILED")
+
+if __name__ == "__main__":
+    main()
diff --git a/dream_layer_backend/test_report_system.py b/dream_layer_backend/test_report_system.py
new file mode 100644
index 00000000..0291e8b1
--- /dev/null
+++ b/dream_layer_backend/test_report_system.py
@@ -0,0 +1,532 @@
+#!/usr/bin/env python3
+"""
+Comprehensive test suite for the DreamLayer Report Generation System
+Tests both backend functionality and API endpoints
+"""
+
+import os
+import json
+import tempfile
+import shutil
+import zipfile
+import csv
+import time
+import requests
+import threading
+from pathlib import Path
+from typing import Dict, Any
+import unittest
+from unittest.mock import patch, MagicMock
+
+# Import the components we're testing
+from report_generator import ReportGenerator, ImageRecord
+
+
+class TestImageRecord(unittest.TestCase):
+    """Test cases for ImageRecord schema validation"""
+    
+    def test_required_columns(self):
+        """Test that required columns are correctly defined"""
+        required = ImageRecord.get_required_columns()
+        expected = [
+            'id', 'filename', 'relative_path', 'prompt', 'negative_prompt',
+            'model_name', 'sampler_name', 'steps', 'cfg_scale', 'width', 
+            'height', 'seed', 'timestamp', 'generation_type', 'batch_index'
+        ]
+        self.assertEqual(required, expected)
+    
+    def test_csv_schema_validation_valid(self):
+        """Test CSV validation with valid schema"""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.csv', delete=False) as f:
+            # Write valid CSV with all required columns
+            writer = csv.DictWriter(f, fieldnames=ImageRecord.get_required_columns())
+            writer.writeheader()
+            writer.writerow({
+                'id': 'test1',
+                'filename': 'test.png',
+                'relative_path': 'grids/txt2img/test.png',
+                'prompt': 'test prompt',
+                'negative_prompt': 'test negative',
+                'model_name': 'sd15.safetensors',
+                'sampler_name': 'euler',
+                'steps': 20,
+                'cfg_scale': 7.0,
+                'width': 512,
+                'height': 512,
+                'seed': 12345,
+                'timestamp': '2024-01-01T00:00:00',
+                'generation_type': 'txt2img',
+                'batch_index': 0
+            })
+            
+        try:
+            result = ImageRecord.validate_csv_schema(f.name)
+            self.assertTrue(result['valid'])
+            self.assertEqual(result['row_count'], 1)
+            self.assertEqual(len(result['missing_columns']), 0)
+        finally:
+            os.unlink(f.name)
+    
+    def test_csv_schema_validation_missing_columns(self):
+        """Test CSV validation with missing required columns"""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.csv', delete=False) as f:
+            # Write CSV missing some required columns
+            writer = csv.DictWriter(f, fieldnames=['id', 'filename', 'prompt'])
+            writer.writeheader()
+            writer.writerow({
+                'id': 'test1',
+                'filename': 'test.png',
+                'prompt': 'test prompt'
+            })
+            
+        try:
+            result = ImageRecord.validate_csv_schema(f.name)
+            self.assertFalse(result['valid'])
+            self.assertGreater(len(result['missing_columns']), 0)
+            self.assertIn('negative_prompt', result['missing_columns'])
+            self.assertIn('model_name', result['missing_columns'])
+        finally:
+            os.unlink(f.name)
+    
+    def test_csv_schema_validation_nonexistent_file(self):
+        """Test CSV validation with non-existent file"""
+        result = ImageRecord.validate_csv_schema('/nonexistent/file.csv')
+        self.assertFalse(result['valid'])
+        self.assertIn('error', result)
+
+
+class TestReportGenerator(unittest.TestCase):
+    """Test cases for ReportGenerator functionality"""
+    
+    def setUp(self):
+        """Set up test environment"""
+        self.test_dir = tempfile.mkdtemp(prefix="dreamlayer_test_")
+        self.served_images_dir = os.path.join(self.test_dir, "served_images")
+        self.reports_dir = os.path.join(self.test_dir, "reports")
+        os.makedirs(self.served_images_dir, exist_ok=True)
+        os.makedirs(self.reports_dir, exist_ok=True)
+        
+        # Create sample image files
+        self.sample_images = [
+            "txt2img_sample_1.png",
+            "txt2img_sample_2.png",
+            "img2img_sample_1.png"
+        ]
+        
+        for img_name in self.sample_images:
+            img_path = os.path.join(self.served_images_dir, img_name)
+            with open(img_path, 'wb') as f:
+                f.write(b"FAKE_PNG_DATA" * 100)
+        
+        # Create sample gallery data
+        self.gallery_data = {
+            "txt2img": [
+                {
+                    "id": "txt2img_1",
+                    "filename": "txt2img_sample_1.png",
+                    "url": "http://localhost:5001/api/images/txt2img_sample_1.png",
+                    "prompt": "A beautiful landscape",
+                    "negativePrompt": "ugly, blurry",
+                    "timestamp": "2024-01-15T10:30:00.000Z",
+                    "settings": {
+                        "model_name": "sd15.safetensors",
+                        "sampler_name": "euler",
+                        "steps": 20,
+                        "cfg_scale": 7.0,
+                        "width": 512,
+                        "height": 512,
+                        "seed": 12345
+                    }
+                },
+                {
+                    "id": "txt2img_2",
+                    "filename": "txt2img_sample_2.png",
+                    "url": "http://localhost:5001/api/images/txt2img_sample_2.png",
+                    "prompt": "A cyberpunk city",
+                    "negativePrompt": "low quality",
+                    "timestamp": "2024-01-15T11:00:00.000Z",
+                    "settings": {
+                        "model_name": "sd15.safetensors",
+                        "sampler_name": "dpm++",
+                        "steps": 25,
+                        "cfg_scale": 8.0,
+                        "width": 768,
+                        "height": 768,
+                        "seed": 67890
+                    }
+                }
+            ],
+            "img2img": [
+                {
+                    "id": "img2img_1",
+                    "filename": "img2img_sample_1.png",
+                    "url": "http://localhost:5001/api/images/img2img_sample_1.png",
+                    "prompt": "Enhanced version of input",
+                    "negativePrompt": "distorted",
+                    "timestamp": "2024-01-15T12:00:00.000Z",
+                    "settings": {
+                        "model_name": "sd15.safetensors",
+                        "sampler_name": "euler",
+                        "steps": 30,
+                        "cfg_scale": 7.5,
+                        "width": 512,
+                        "height": 512,
+                        "seed": 54321,
+                        "denoising_strength": 0.7,
+                        "input_image": "data:image/png;base64,..."
+                    }
+                }
+            ]
+        }
+    
+    def tearDown(self):
+        """Clean up test environment"""
+        shutil.rmtree(self.test_dir)
+    
+    def create_test_generator(self) -> ReportGenerator:
+        """Create a ReportGenerator configured for testing"""
+        # Store instance variables for the inner class to access
+        served_images_dir = self.served_images_dir
+        reports_dir = self.reports_dir
+        test_dir = self.test_dir
+        gallery_data = self.gallery_data
+        
+        class TestReportGenerator(ReportGenerator):
+            def __init__(self):
+                self.served_images_dir = served_images_dir
+                self.reports_dir = reports_dir
+                self.output_dir = os.path.join(test_dir, 'output')
+                os.makedirs(self.output_dir, exist_ok=True)
+            
+            def fetch_gallery_data(self):
+                return gallery_data
+            
+            def _get_models_info(self):
+                return {
+                    'checkpoints': ['sd15.safetensors', 'flux1-dev.safetensors'],
+                    'loras': ['style_lora.safetensors'],
+                    'controlnet': ['canny_controlnet.safetensors']
+                }
+        
+        return TestReportGenerator()
+    
+    def test_scan_served_images(self):
+        """Test scanning served images directory"""
+        generator = self.create_test_generator()
+        result = generator._scan_served_images()
+        
+        # Should find images and classify them
+        self.assertIn('txt2img', result)
+        self.assertIn('img2img', result)
+        self.assertGreater(len(result['txt2img']), 0)
+        self.assertGreater(len(result['img2img']), 0)
+    
+    def test_create_csv_records(self):
+        """Test creation of CSV records from gallery data"""
+        generator = self.create_test_generator()
+        records = generator.create_csv_records(self.gallery_data)
+        
+        self.assertEqual(len(records), 3)  # 2 txt2img + 1 img2img
+        
+        # Check first record structure
+        record = records[0]
+        self.assertIsInstance(record, ImageRecord)
+        self.assertIn(record.generation_type, ['txt2img', 'img2img'])
+        self.assertIsNotNone(record.prompt)
+        self.assertIsNotNone(record.model_name)
+    
+    def test_write_csv(self):
+        """Test CSV writing functionality"""
+        generator = self.create_test_generator()
+        records = generator.create_csv_records(self.gallery_data)
+        
+        csv_path = os.path.join(self.test_dir, 'test_results.csv')
+        generator.write_csv(records, csv_path)
+        
+        # Verify CSV was created and has correct structure
+        self.assertTrue(os.path.exists(csv_path))
+        
+        validation = ImageRecord.validate_csv_schema(csv_path)
+        self.assertTrue(validation['valid'])
+        self.assertEqual(validation['row_count'], 3)
+    
+    def test_generate_config_json(self):
+        """Test configuration JSON generation"""
+        generator = self.create_test_generator()
+        config = generator.generate_config_json()
+        
+        # Check required sections
+        self.assertIn('report_metadata', config)
+        self.assertIn('system_settings', config)
+        self.assertIn('available_models', config)
+        self.assertIn('directory_structure', config)
+        
+        # Check metadata
+        self.assertIn('generated_at', config['report_metadata'])
+        self.assertIn('dreamlayer_version', config['report_metadata'])
+        
+        # Check models
+        self.assertIn('checkpoints', config['available_models'])
+    
+    def test_copy_images_to_bundle(self):
+        """Test copying images to bundle structure"""
+        generator = self.create_test_generator()
+        records = generator.create_csv_records(self.gallery_data)
+        
+        bundle_dir = os.path.join(self.test_dir, 'bundle')
+        os.makedirs(bundle_dir, exist_ok=True)
+        
+        result = generator.copy_images_to_bundle(records, bundle_dir)
+        
+        # Check that images were copied
+        self.assertGreater(len(result['copied_files']), 0)
+        self.assertIn('txt2img', result['generation_types'])
+        self.assertIn('img2img', result['generation_types'])
+        
+        # Verify grids directory structure
+        grids_dir = os.path.join(bundle_dir, 'grids')
+        self.assertTrue(os.path.exists(grids_dir))
+        self.assertTrue(os.path.exists(os.path.join(grids_dir, 'txt2img')))
+        self.assertTrue(os.path.exists(os.path.join(grids_dir, 'img2img')))
+    
+    def test_create_report_bundle(self):
+        """Test complete report bundle creation"""
+        generator = self.create_test_generator()
+        result = generator.create_report_bundle("test_report.zip")
+        
+        # Check result status
+        self.assertEqual(result['status'], 'success')
+        self.assertEqual(result['total_images'], 3)
+        self.assertTrue(result['csv_validation']['valid'])
+        self.assertTrue(result['path_validation']['valid'])
+        
+        # Check that ZIP file was created
+        self.assertTrue(os.path.exists(result['report_path']))
+        self.assertGreater(result['bundle_size_bytes'], 0)
+        
+        # Verify ZIP contents
+        with zipfile.ZipFile(result['report_path'], 'r') as zipf:
+            zip_contents = zipf.namelist()
+            
+            # Check required files
+            self.assertIn('results.csv', zip_contents)
+            self.assertIn('config.json', zip_contents)
+            self.assertIn('README.md', zip_contents)
+            
+            # Check grids structure
+            self.assertTrue(any(path.startswith('grids/txt2img/') for path in zip_contents))
+            self.assertTrue(any(path.startswith('grids/img2img/') for path in zip_contents))
+    
+    def test_validate_csv_paths_in_zip(self):
+        """Test CSV path validation against ZIP contents"""
+        generator = self.create_test_generator()
+        result = generator.create_report_bundle("test_validation.zip")
+        
+        self.assertEqual(result['status'], 'success')
+        
+        # Extract and validate the generated CSV and ZIP
+        csv_path = os.path.join(self.test_dir, 'extracted_results.csv')
+        with zipfile.ZipFile(result['report_path'], 'r') as zipf:
+            with zipf.open('results.csv') as csv_file:
+                with open(csv_path, 'wb') as f:
+                    f.write(csv_file.read())
+        
+        validation = generator._validate_csv_paths_in_zip(csv_path, result['report_path'])
+        self.assertTrue(validation['valid'])
+        self.assertEqual(len(validation['missing_paths']), 0)
+
+
+class TestAPIEndpoints(unittest.TestCase):
+    """Test cases for API endpoints (requires running server)"""
+    
+    BASE_URL = "http://localhost:5000"
+    
+    @classmethod
+    def setUpClass(cls):
+        """Check if server is running"""
+        try:
+            response = requests.get(f"{cls.BASE_URL}/", timeout=5)
+            cls.server_available = response.status_code == 200
+        except:
+            cls.server_available = False
+    
+    def setUp(self):
+        """Skip tests if server not available"""
+        if not self.server_available:
+            self.skipTest("Server not available")
+    
+    def test_gallery_data_endpoint(self):
+        """Test updating gallery data via API"""
+        test_data = {
+            "txt2img": [
+                {
+                    "id": "api_test_1",
+                    "filename": "api_test.png",
+                    "prompt": "API test image",
+                    "negativePrompt": "test negative",
+                    "timestamp": "2024-01-01T00:00:00.000Z",
+                    "settings": {
+                        "model_name": "test_model.safetensors",
+                        "sampler_name": "euler",
+                        "steps": 20,
+                        "cfg_scale": 7.0,
+                        "width": 512,
+                        "height": 512,
+                        "seed": 12345
+                    }
+                }
+            ],
+            "img2img": []
+        }
+        
+        response = requests.post(
+            f"{self.BASE_URL}/api/gallery-data",
+            json=test_data,
+            timeout=10
+        )
+        
+        self.assertEqual(response.status_code, 200)
+        data = response.json()
+        self.assertEqual(data['status'], 'success')
+    
+    def test_report_generation_endpoint(self):
+        """Test report generation via API"""
+        # First update gallery data
+        self.test_gallery_data_endpoint()
+        
+        # Then generate report
+        response = requests.post(
+            f"{self.BASE_URL}/api/reports/generate",
+            json={"filename": "api_test_report.zip"},
+            timeout=30
+        )
+        
+        self.assertEqual(response.status_code, 200)
+        data = response.json()
+        self.assertEqual(data['status'], 'success')
+        self.assertIn('report_filename', data)
+        self.assertIn('total_images', data)
+        self.assertIn('csv_validation', data)
+        self.assertIn('path_validation', data)
+    
+    def test_csv_validation_endpoint(self):
+        """Test CSV validation endpoint"""
+        # Create a test CSV file
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.csv', delete=False) as f:
+            writer = csv.DictWriter(f, fieldnames=ImageRecord.get_required_columns())
+            writer.writeheader()
+            writer.writerow({
+                'id': 'test1',
+                'filename': 'test.png',
+                'relative_path': 'grids/txt2img/test.png',
+                'prompt': 'test prompt',
+                'negative_prompt': 'test negative',
+                'model_name': 'sd15.safetensors',
+                'sampler_name': 'euler',
+                'steps': 20,
+                'cfg_scale': 7.0,
+                'width': 512,
+                'height': 512,
+                'seed': 12345,
+                'timestamp': '2024-01-01T00:00:00',
+                'generation_type': 'txt2img',
+                'batch_index': 0
+            })
+        
+        try:
+            response = requests.post(
+                f"{self.BASE_URL}/api/reports/validate-csv",
+                json={"csv_path": f.name},
+                timeout=10
+            )
+            
+            self.assertEqual(response.status_code, 200)
+            data = response.json()
+            self.assertEqual(data['status'], 'success')
+            self.assertTrue(data['validation']['valid'])
+        finally:
+            os.unlink(f.name)
+
+
+def run_integration_tests():
+    """Run comprehensive integration tests"""
+    print("🧪 Running DreamLayer Report System Integration Tests")
+    print("=" * 60)
+    
+    # Create test suite
+    loader = unittest.TestLoader()
+    suite = unittest.TestSuite()
+    
+    # Add test cases
+    suite.addTests(loader.loadTestsFromTestCase(TestImageRecord))
+    suite.addTests(loader.loadTestsFromTestCase(TestReportGenerator))
+    suite.addTests(loader.loadTestsFromTestCase(TestAPIEndpoints))
+    
+    # Run tests
+    runner = unittest.TextTestRunner(verbosity=2)
+    result = runner.run(suite)
+    
+    print("=" * 60)
+    if result.wasSuccessful():
+        print("🎉 All tests passed successfully!")
+        return 0
+    else:
+        print(f"❌ {len(result.failures)} test(s) failed, {len(result.errors)} error(s)")
+        return 1
+
+
+def test_manual_report_generation():
+    """Manual test for report generation with sample data"""
+    print("\n🔧 Manual Report Generation Test")
+    print("-" * 40)
+    
+    try:
+        # Create sample environment
+        test_dir = tempfile.mkdtemp(prefix="manual_test_")
+        served_images_dir = os.path.join(test_dir, "served_images")
+        os.makedirs(served_images_dir, exist_ok=True)
+        
+        # Create sample images
+        for i in range(5):
+            img_path = os.path.join(served_images_dir, f"sample_{i}.png")
+            with open(img_path, 'wb') as f:
+                f.write(b"SAMPLE_IMAGE_DATA" * 50)
+        
+        # Create generator
+        class ManualTestGenerator(ReportGenerator):
+            def __init__(self):
+                self.served_images_dir = served_images_dir
+                self.reports_dir = os.path.join(test_dir, "reports")
+                self.output_dir = os.path.join(test_dir, "output")
+                os.makedirs(self.reports_dir, exist_ok=True)
+                os.makedirs(self.output_dir, exist_ok=True)
+        
+        generator = ManualTestGenerator()
+        result = generator.create_report_bundle()
+        
+        print(f"✅ Manual test completed successfully!")
+        print(f"   Report: {result['report_filename']}")
+        print(f"   Size: {result['bundle_size_bytes']} bytes")
+        print(f"   Images: {result['total_images']}")
+        
+        return result['report_path']
+        
+    except Exception as e:
+        print(f"❌ Manual test failed: {e}")
+        return None
+    finally:
+        # Cleanup
+        if 'test_dir' in locals():
+            shutil.rmtree(test_dir)
+
+
+if __name__ == "__main__":
+    import sys
+    
+    # Run integration tests
+    exit_code = run_integration_tests()
+    
+    # Run manual test
+    manual_result = test_manual_report_generation()
+    
+    sys.exit(exit_code)
diff --git a/dream_layer_backend/txt2img_workflow.py b/dream_layer_backend/txt2img_workflow.py
index b514b4a2..4c92da3b 100644
--- a/dream_layer_backend/txt2img_workflow.py
+++ b/dream_layer_backend/txt2img_workflow.py
@@ -45,13 +45,14 @@ def transform_to_txt2img_workflow(data):
         width = max(64, min(2048, int(data.get('width', 512))))
         height = max(64, min(2048, int(data.get('height', 512))))
 
-        # Batch parameters with validation (from smallFeatures)
-        # Clamp between 1 and 8
-        batch_size = max(1, min(8, int(data.get('batch_size', 1))))
-        print(f"\nBatch size: {batch_size}")
+        
+        # Batch parameters with validation (from smallFeatures) - LIMITED TO 1 FOR PERFORMANCE
+        batch_size = 1  # Force batch_size to 1 for faster generation
+        print(f"\nBatch size: {batch_size} (forced to 1 for performance)")
+        
+        # Sampling parameters with validation - LIMITED STEPS FOR FASTER GENERATION
+        steps = min(15, max(1, int(data.get('steps', 15))))  # Max 15 steps for speed
 
-        # Sampling parameters with validation
-        steps = max(1, min(150, int(data.get('steps', 20))))
         cfg_scale = max(1.0, min(20.0, float(data.get('cfg_scale', 7.0))))
 
         # Get sampler name and map it to ComfyUI format (from smallFeatures)
@@ -71,14 +72,22 @@ def transform_to_txt2img_workflow(data):
         except (ValueError, TypeError):
             seed = random.randint(0, 2**31 - 1)
 
-        # Update the data with the actual seed used
-        data['seed'] = seed
+    # Update the data with the actual seed used
+    data['seed'] = seed
 
-        # Handle model name validation
+    # Handle model name validation
+    if data.get("force_fast_model", False):
+        model_name = "v15PrunedEmaonly_v15PrunedEmaonly.safetensors"  # Force fast model
+        print(f"Forcing model: {model_name} for faster generation")
+    else:
         model_name = data.get('model_name', 'juggernautXL_v8Rundiffusion.safetensors')
-        
-        # Check if it's a closed-source model (DALL-E, FLUX, Ideogram, Runway, Stability AI, Luma, Banana, etc.)
-        closed_source_models = ['dall-e-3', 'dall-e-2', 'flux-pro', 'flux-dev', 'ideogram-v3', 'runway-gen4', 'stability-sdxl', 'stability-sd-turbo', 'photon-1', 'photon-flash-1', 'banana-gemini']
+
+    # Check if it's a closed-source model (DALL-E, FLUX, Ideogram, Runway, Stability AI, Luma, Banana, etc.)
+    closed_source_models = [
+        'dall-e-3', 'dall-e-2', 'flux-pro', 'flux-dev', 'ideogram-v3',
+        'runway-gen4', 'stability-sdxl', 'stability-sd-turbo',
+        'photon-1', 'photon-flash-1', 'banana-gemini'
+    ]
         
         if model_name in closed_source_models:
             print(f"🎨 Using closed-source model: {model_name}")
diff --git a/dream_layer_backend/update_gallery_with_real_images.py b/dream_layer_backend/update_gallery_with_real_images.py
new file mode 100644
index 00000000..8a747f7b
--- /dev/null
+++ b/dream_layer_backend/update_gallery_with_real_images.py
@@ -0,0 +1,140 @@
+#!/usr/bin/env python3
+"""
+Create gallery data from the recently generated images
+"""
+
+import json
+import os
+import requests
+from datetime import datetime, timezone
+
+def create_gallery_data_from_served_images():
+    """Create gallery data from actual served images"""
+    served_images_dir = "served_images"
+    
+    # Get all PNG files from served_images
+    image_files = [f for f in os.listdir(served_images_dir) if f.endswith('.png')]
+    image_files.sort()  # Sort by filename
+    
+    print(f"Found {len(image_files)} images: {image_files}")
+    
+    # Create realistic gallery data for these images
+    gallery_data = {
+        "txt2img": [],
+        "img2img": []
+    }
+    
+    # Sample prompts for the generated images
+    prompts = [
+        "simple red apple on table, photorealistic",
+        "cute kitten playing with ball",
+        "epic mountain landscape at sunset, dramatic clouds, golden hour lighting",
+        "professional portrait photography, studio lighting, high quality"
+    ]
+    
+    for i, filename in enumerate(image_files):
+        prompt = prompts[i] if i < len(prompts) else f"Generated image {i+1}"
+        
+        # Create realistic metadata
+        image_data = {
+            "id": f"real_gen_{i+1:03d}",
+            "filename": filename,
+            "url": f"http://localhost:5001/api/images/{filename}",
+            "prompt": prompt,
+            "negativePrompt": "blurry, low quality, watermark, distorted",
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "settings": {
+                "model_name": "v15PrunedEmaonly_v15PrunedEmaonly.safetensors",
+                "sampler_name": "euler",
+                "steps": 15,
+                "cfg_scale": 7.0,
+                "width": 512,
+                "height": 512 if i % 2 == 0 else 256,  # Mix of sizes
+                "seed": 1000000 + i * 12345,
+                "batch_size": 1
+            }
+        }
+        
+        # Alternate between txt2img and img2img for variety
+        if i % 3 == 0:
+            # Add img2img specific settings
+            image_data["settings"]["denoising_strength"] = 0.75
+            gallery_data["img2img"].append(image_data)
+        else:
+            gallery_data["txt2img"].append(image_data)
+    
+    return gallery_data
+
+def send_gallery_data_to_backend(gallery_data):
+    """Send gallery data to the backend"""
+    try:
+        response = requests.post(
+            'http://localhost:5002/api/gallery-data',
+            json=gallery_data,
+            headers={'Content-Type': 'application/json'}
+        )
+        
+        if response.status_code == 200:
+            print("✅ Gallery data sent successfully!")
+            print(f"Response: {response.json()}")
+            return True
+        else:
+            print(f"❌ Failed to send gallery data: {response.status_code}")
+            print(f"Response: {response.text}")
+            return False
+            
+    except Exception as e:
+        print(f"❌ Error sending gallery data: {e}")
+        return False
+
+def test_report_generation():
+    """Test report generation with the real gallery data"""
+    try:
+        response = requests.post(
+            'http://localhost:5002/api/reports/generate',
+            json={'filename': 'test_real_images_report.zip'},
+            headers={'Content-Type': 'application/json'}
+        )
+        
+        if response.status_code == 200:
+            result = response.json()
+            print("✅ Report generated successfully!")
+            print(f"Total images: {result.get('total_images')}")
+            print(f"File size: {result.get('bundle_size_bytes')} bytes")
+            print(f"CSV valid: {result.get('csv_validation', {}).get('valid')}")
+            print(f"Paths valid: {result.get('path_validation', {}).get('valid')}")
+            return result.get('report_filename')
+        else:
+            print(f"❌ Failed to generate report: {response.status_code}")
+            print(f"Response: {response.text}")
+            return None
+            
+    except Exception as e:
+        print(f"❌ Error generating report: {e}")
+        return None
+
+def main():
+    print("🔄 Creating gallery data from real images...")
+    
+    gallery_data = create_gallery_data_from_served_images()
+    
+    print(f"📊 Created gallery data:")
+    print(f"  - txt2img: {len(gallery_data['txt2img'])} images")
+    print(f"  - img2img: {len(gallery_data['img2img'])} images")
+    print(f"  - Total: {len(gallery_data['txt2img']) + len(gallery_data['img2img'])} images")
+    
+    print("\n🚀 Sending gallery data to backend...")
+    if send_gallery_data_to_backend(gallery_data):
+        print("\n📋 Testing report generation...")
+        report_filename = test_report_generation()
+        
+        if report_filename:
+            print(f"\n🎉 Success! Report created: {report_filename}")
+            print("You can now test the Reports tab in the frontend!")
+        else:
+            print("\n❌ Report generation failed")
+    else:
+        print("\n❌ Failed to send gallery data")
+
+if __name__ == "__main__":
+    main()
diff --git a/dream_layer_frontend/src/components/Navigation/TabsNav.tsx b/dream_layer_frontend/src/components/Navigation/TabsNav.tsx
index 0dd92f2e..455a0cfd 100644
--- a/dream_layer_frontend/src/components/Navigation/TabsNav.tsx
+++ b/dream_layer_frontend/src/components/Navigation/TabsNav.tsx
@@ -1,21 +1,23 @@
-
 import {
   FileText,
   ImageIcon,
   Settings,
   GalleryHorizontal,
   HardDrive,
+  FolderArchive,
   History,
   Download,
   MessageSquare
 } from "lucide-react";
 
+
 const tabs = [
   { id: "txt2img", label: "Txt2Img", icon: FileText },
   { id: "img2img", label: "Img2Img", icon: ImageIcon },
   { id: "img2txt", label: "Img2Txt", icon: MessageSquare },
   { id: "extras", label: "Extras", icon: GalleryHorizontal },
   { id: "models", label: "Models", icon: HardDrive },
+  { id: "reports", label: "Reports", icon: FolderArchive },
   { id: "pnginfo", label: "PNG Info", icon: FileText },
   { id: "configurations", label: "Configurations", icon: Settings },
   { id: "runregistry", label: "Run Registry", icon: History },
diff --git a/dream_layer_frontend/src/components/ReportGenerator.tsx b/dream_layer_frontend/src/components/ReportGenerator.tsx
new file mode 100644
index 00000000..62721188
--- /dev/null
+++ b/dream_layer_frontend/src/components/ReportGenerator.tsx
@@ -0,0 +1,493 @@
+import React, { useState, useEffect } from 'react';
+import { Button } from '@/components/ui/button';
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card';
+import { Badge } from '@/components/ui/badge';
+import { Progress } from '@/components/ui/progress';
+import { AlertCircle, Download, FileText, FolderOpen, CheckCircle, RefreshCw } from 'lucide-react';
+import { Alert, AlertDescription } from '@/components/ui/alert';
+import { useImg2ImgGalleryStore } from '@/stores/useImg2ImgGalleryStore';
+import { useTxt2ImgGalleryStore } from '@/stores/useTxt2ImgGalleryStore';
+import { useExtrasGalleryStore } from '@/stores/useExtrasGalleryStore';
+import { GallerySync } from '@/utils/gallerySync';
+
+interface ReportGenerationResult {
+  status: 'success' | 'error';
+  message: string;
+  report_path?: string;
+  report_filename?: string;
+  total_images?: number;
+  csv_validation?: {
+    valid: boolean;
+    required_columns: string[];
+    actual_columns: string[];
+    missing_columns: string[];
+    row_count: number;
+  };
+  path_validation?: {
+    valid: boolean;
+    total_csv_paths: number;
+    valid_paths: number;
+    missing_paths: string[];
+  };
+  bundle_size_bytes?: number;
+  generation_types?: string[];
+}
+
+export const ReportGenerator: React.FC = () => {
+  const [isGenerating, setIsGenerating] = useState(false);
+  const [progress, setProgress] = useState(0);
+  const [result, setResult] = useState<ReportGenerationResult | null>(null);
+  const [error, setError] = useState<string | null>(null);
+  const [backendImageCount, setBackendImageCount] = useState(0);
+  const [backendTxt2imgCount, setBackendTxt2imgCount] = useState(0);
+  const [backendImg2imgCount, setBackendImg2imgCount] = useState(0);
+  const [backendExtrasCount, setBackendExtrasCount] = useState(0);
+  const [backendGenerationTypes, setBackendGenerationTypes] = useState<string[]>([]);
+  const [isLoading, setIsLoading] = useState(true);
+
+  const txt2imgImages = useTxt2ImgGalleryStore((state) => state.images);
+  const img2imgImages = useImg2ImgGalleryStore((state) => state.images);
+  const extrasImages = useExtrasGalleryStore((state) => state.images);
+
+  const frontendTotalImages = txt2imgImages.length + img2imgImages.length + extrasImages.length;
+  
+  // Use backend count if frontend stores are empty (page refresh scenario)
+  const totalImages = frontendTotalImages > 0 ? frontendTotalImages : backendImageCount;
+  
+  // Determine generation types (frontend or backend)
+  const getGenerationTypes = () => {
+    if (frontendTotalImages > 0) {
+      const types = [];
+      if (txt2imgImages.length > 0) types.push('txt2img');
+      if (img2imgImages.length > 0) types.push('img2img');
+      if (extrasImages.length > 0) types.push('extras');
+      return types;
+    } else {
+      return backendGenerationTypes;
+    }
+  };
+  
+  const generationTypes = getGenerationTypes();
+  
+  // Format generation type display
+  const getGenerationTypeDisplay = () => {
+    if (generationTypes.length === 0) return '0';
+    if (generationTypes.length === 1) {
+      return generationTypes[0] === 'txt2img' ? 'Txt2Img' : 
+             generationTypes[0] === 'img2img' ? 'Img2Img' : 'Extras';
+    }
+    return 'Multiple';
+  };
+
+  // Fetch backend image count on component mount
+  const fetchBackendImageCount = async (skipLoading = false) => {
+    try {
+      if (!skipLoading) setIsLoading(true);
+      
+      // Use dedicated status endpoint to get current backend image count
+      const response = await fetch('http://localhost:5002/api/reports/status', {
+        method: 'GET',
+        headers: { 'Content-Type': 'application/json' }
+      });
+
+      if (response.ok) {
+        const result = await response.json();
+        const newCount = result.total_images || 0;
+        const txt2imgCount = result.txt2img_count || 0;
+        const img2imgCount = result.img2img_count || 0;
+        const extrasCount = result.extras_count || 0;
+        const types = result.generation_types || [];
+        setBackendImageCount(newCount);
+        setBackendTxt2imgCount(txt2imgCount);
+        setBackendImg2imgCount(img2imgCount);
+        setBackendExtrasCount(extrasCount);
+        setBackendGenerationTypes(types);
+        console.log(`📊 Backend has ${newCount} images available for reports (${txt2imgCount} txt2img, ${img2imgCount} img2img, ${extrasCount} extras)`);
+      } else {
+        console.warn('Could not fetch backend image count');
+        setBackendImageCount(0);
+        setBackendTxt2imgCount(0);
+        setBackendImg2imgCount(0);
+        setBackendExtrasCount(0);
+        setBackendGenerationTypes([]);
+      }
+    } catch (error) {
+      console.error('Error fetching backend image count:', error);
+      setBackendImageCount(0);
+      setBackendTxt2imgCount(0);
+      setBackendImg2imgCount(0);
+      setBackendGenerationTypes([]);
+    } finally {
+      if (!skipLoading) setIsLoading(false);
+    }
+  };
+
+  useEffect(() => {
+    const initializeApp = async () => {
+      // Ensure fresh start if backend is empty but frontend has old data
+      await GallerySync.ensureFreshStart();
+      // Then fetch current backend count
+      fetchBackendImageCount();
+    };
+    
+    initializeApp();
+  }, []);
+
+  // Refetch when component becomes visible (user switches to Reports tab)
+  useEffect(() => {
+    const handleVisibilityChange = () => {
+      if (!document.hidden) {
+        console.log('🔍 Reports tab became visible, refreshing data...');
+        fetchBackendImageCount(true);
+      }
+    };
+
+    const handleFocus = () => {
+      console.log('🔍 Window focused, refreshing Reports data...');
+      fetchBackendImageCount(true);
+    };
+
+    document.addEventListener('visibilitychange', handleVisibilityChange);
+    window.addEventListener('focus', handleFocus);
+
+    return () => {
+      document.removeEventListener('visibilitychange', handleVisibilityChange);
+      window.removeEventListener('focus', handleFocus);
+    };
+  }, []);
+
+  // Also refetch when frontend stores change (after new generations)
+  useEffect(() => {
+    if (frontendTotalImages > 0 && frontendTotalImages !== backendImageCount) {
+      // Frontend has different count than backend, refetch backend count
+      console.log(`🔄 Frontend count (${frontendTotalImages}) differs from backend (${backendImageCount}), refreshing...`);
+      setTimeout(() => {
+        fetchBackendImageCount(true); // Skip loading state for refresh
+      }, 1000); // Give time for sync to complete
+    }
+  }, [frontendTotalImages, backendImageCount]);
+
+  // Additional effect to listen to individual store changes for more responsive updates
+  useEffect(() => {
+    if (txt2imgImages.length > 0 || img2imgImages.length > 0 || extrasImages.length > 0) {
+      console.log(`🔄 Store change detected: txt2img=${txt2imgImages.length}, img2img=${img2imgImages.length}, extras=${extrasImages.length}`);
+      setTimeout(() => {
+        fetchBackendImageCount(true);
+      }, 1500); // Slightly longer delay for cross-tab scenarios
+    }
+  }, [txt2imgImages.length, img2imgImages.length, extrasImages.length]);
+
+
+  const updateGalleryData = async () => {
+    try {
+      const galleryData = {
+        txt2img: txt2imgImages,
+        img2img: img2imgImages,
+        extras: extrasImages
+      };
+
+      const response = await fetch('http://localhost:5002/api/gallery-data', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(galleryData)
+      });
+
+      if (!response.ok) {
+        throw new Error(`Failed to update gallery data: ${response.statusText}`);
+      }
+
+      console.log('Gallery data updated successfully');
+    } catch (error) {
+      console.error('Failed to update gallery data:', error);
+      throw error;
+    }
+  };
+
+  const generateReport = async () => {
+    if (totalImages === 0) {
+      setError('No images available to generate report. Please generate some images first.');
+      return;
+    }
+
+    setIsGenerating(true);
+    setProgress(0);
+    setError(null);
+    setResult(null);
+
+    try {
+      // Step 1: Update gallery data (20%) - only if frontend has data
+      setProgress(20);
+      if (frontendTotalImages > 0) {
+        await updateGalleryData();
+      } else {
+        console.log('Using existing backend data for report generation');
+      }
+
+      // Step 2: Generate report (80%)
+      setProgress(50);
+      const response = await fetch('http://localhost:5002/api/reports/generate', {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify({
+          filename: `dreamlayer_report_${new Date().toISOString().slice(0, 19).replace(/[:-]/g, '')}.zip`
+        })
+      });
+
+      setProgress(80);
+      const data: ReportGenerationResult = await response.json();
+
+      if (response.ok && data.status === 'success') {
+        setProgress(100);
+        setResult(data);
+      } else {
+        throw new Error(data.message || 'Failed to generate report');
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : 'An unknown error occurred');
+    } finally {
+      setIsGenerating(false);
+      if (!result) {
+        setProgress(0);
+      }
+    }
+  };
+
+  const downloadReport = async () => {
+    if (result?.report_filename) {
+      const downloadUrl = `http://localhost:5002/api/reports/download/${result.report_filename}`;
+      window.open(downloadUrl, '_blank');
+      
+      // Clear session after download
+      await clearSession();
+    }
+  };
+
+  const clearSession = async () => {
+    try {
+      console.log('🧹 Clearing session after report download...');
+      
+      // Use centralized sync to clear all data
+      await GallerySync.clearAll();
+      
+      // Reset local state
+      setResult(null);
+      setError(null);
+      setProgress(0);
+      setBackendImageCount(0);
+      setBackendTxt2imgCount(0);
+      setBackendImg2imgCount(0);
+      setBackendExtrasCount(0);
+      setBackendGenerationTypes([]);
+      
+      // Refresh backend count to confirm it's 0
+      await fetchBackendImageCount(true);
+      
+      console.log('✅ Session cleared successfully');
+    } catch (error) {
+      console.error('❌ Error clearing session:', error);
+    }
+  };
+
+  const formatFileSize = (bytes: number): string => {
+    const units = ['B', 'KB', 'MB', 'GB'];
+    let size = bytes;
+    let unitIndex = 0;
+    
+    while (size >= 1024 && unitIndex < units.length - 1) {
+      size /= 1024;
+      unitIndex++;
+    }
+    
+    return `${size.toFixed(1)} ${units[unitIndex]}`;
+  };
+
+  return (
+    <Card className="w-full max-w-2xl mx-auto">
+      <CardHeader>
+        <CardTitle className="flex items-center gap-2 justify-between">
+          <div className="flex items-center gap-2">
+            <FileText className="h-5 w-5" />
+            Report Generator
+          </div>
+          <Button
+            variant="outline"
+            size="sm"
+            onClick={() => fetchBackendImageCount()}
+            disabled={isLoading}
+            className="ml-auto"
+          >
+            <RefreshCw className={`h-4 w-4 ${isLoading ? 'animate-spin' : ''}`} />
+          </Button>
+        </CardTitle>
+        <CardDescription>
+          Generate a comprehensive report bundle containing all your generated images, metadata, and configuration.
+        </CardDescription>
+      </CardHeader>
+      
+      <CardContent className="space-y-4">
+        {/* Status Overview */}
+        <div className="grid grid-cols-2 gap-4">
+          <div className="text-center p-3 bg-muted rounded-lg">
+            <div className="text-2xl font-bold text-primary">
+              {isLoading ? '...' : totalImages}
+            </div>
+            <div className="text-sm text-muted-foreground">
+              Total Images
+              {frontendTotalImages > 0 && backendImageCount > 0 && frontendTotalImages !== backendImageCount && (
+                <div className="text-xs text-orange-600">
+                  Frontend: {frontendTotalImages}, Backend: {backendImageCount}
+                </div>
+              )}
+            </div>
+          </div>
+          <div className="text-center p-3 bg-muted rounded-lg">
+            <div className="text-2xl font-bold text-primary">
+              {isLoading ? '...' : getGenerationTypeDisplay()}
+            </div>
+            <div className="text-sm text-muted-foreground">Generation Types</div>
+          </div>
+        </div>
+
+        {/* Generation Types */}
+        <div className="flex gap-2 flex-wrap">
+          {frontendTotalImages > 0 ? (
+            <>
+              {txt2imgImages.length > 0 && (
+                <Badge variant="secondary">
+                  Txt2Img ({txt2imgImages.length})
+                </Badge>
+              )}
+              {img2imgImages.length > 0 && (
+                <Badge variant="secondary">
+                  Img2Img ({img2imgImages.length})
+                </Badge>
+              )}
+              {extrasImages.length > 0 && (
+                <Badge variant="secondary">
+                  Extras ({extrasImages.length})
+                </Badge>
+              )}
+            </>
+          ) : backendImageCount > 0 ? (
+            <>
+              {backendTxt2imgCount > 0 && (
+                <Badge variant="secondary">
+                  Txt2Img ({backendTxt2imgCount})
+                </Badge>
+              )}
+              {backendImg2imgCount > 0 && (
+                <Badge variant="secondary">
+                  Img2Img ({backendImg2imgCount})
+                </Badge>
+              )}
+              {backendExtrasCount > 0 && (
+                <Badge variant="secondary">
+                  Extras ({backendExtrasCount})
+                </Badge>
+              )}
+            </>
+          ) : (
+            <Badge variant="outline">
+              {isLoading ? 'Loading...' : 'No images generated'}
+            </Badge>
+          )}
+        </div>
+
+        {/* Progress Bar */}
+        {isGenerating && (
+          <div className="space-y-2">
+            <div className="flex justify-between text-sm">
+              <span>Generating report...</span>
+              <span>{progress}%</span>
+            </div>
+            <Progress value={progress} className="w-full" />
+          </div>
+        )}
+
+        {/* Error Display */}
+        {error && (
+          <Alert variant="destructive">
+            <AlertCircle className="h-4 w-4" />
+            <AlertDescription>{error}</AlertDescription>
+          </Alert>
+        )}
+
+        {/* Success Result */}
+        {result && result.status === 'success' && (
+          <div className="space-y-4">
+            <Alert>
+              <CheckCircle className="h-4 w-4" />
+              <AlertDescription>
+                Report generated successfully! The bundle contains {result.total_images} images across {result.generation_types?.length} generation types.
+              </AlertDescription>
+            </Alert>
+
+            {/* Report Details */}
+            <div className="grid grid-cols-2 gap-4 text-sm">
+              <div>
+                <strong>File Size:</strong> {result.bundle_size_bytes ? formatFileSize(result.bundle_size_bytes) : 'Unknown'}
+              </div>
+              <div>
+                <strong>Generation Types:</strong> {result.generation_types?.join(', ') || 'None'}
+              </div>
+              <div>
+                <strong>CSV Validation:</strong> {result.csv_validation?.valid ? '✅ Valid' : '❌ Invalid'}
+              </div>
+              <div>
+                <strong>Path Validation:</strong> {result.path_validation?.valid ? '✅ All paths resolved' : '❌ Missing paths'}
+              </div>
+            </div>
+
+            {/* Download Button */}
+            <Button 
+              onClick={downloadReport} 
+              className="w-full"
+              size="lg"
+            >
+              <Download className="h-4 w-4 mr-2" />
+              Download Report Bundle
+            </Button>
+          </div>
+        )}
+
+        {/* Generate Button */}
+        <Button 
+          onClick={generateReport} 
+          disabled={isGenerating || totalImages === 0 || isLoading}
+          className="w-full"
+          size="lg"
+        >
+          {isGenerating ? (
+            <>
+              <div className="animate-spin rounded-full h-4 w-4 border-b-2 border-white mr-2"></div>
+              Generating Report...
+            </>
+          ) : (
+            <>
+              <FolderOpen className="h-4 w-4 mr-2" />
+              Generate Report Bundle
+            </>
+          )}
+        </Button>
+
+        {/* Report Contents Info */}
+        <div className="text-xs text-muted-foreground space-y-1">
+          <p><strong>Report Contents:</strong></p>
+          <ul className="ml-4 space-y-1">
+            <li>• <code>results.csv</code> - Complete image metadata with standardized schema</li>
+            <li>• <code>config.json</code> - Current system configuration and settings</li>
+            <li>• <code>grids/</code> - Organized image collections by generation type</li>
+            <li>• <code>README.md</code> - Human-readable report documentation</li>
+          </ul>
+          <p className="mt-2">All paths in the CSV are deterministic and resolve to files within the ZIP bundle.</p>
+        </div>
+      </CardContent>
+    </Card>
+  );
+};
+
+export default ReportGenerator;
diff --git a/dream_layer_frontend/src/features/Extras/ExtrasPage.tsx b/dream_layer_frontend/src/features/Extras/ExtrasPage.tsx
index 65998e31..bd646336 100644
--- a/dream_layer_frontend/src/features/Extras/ExtrasPage.tsx
+++ b/dream_layer_frontend/src/features/Extras/ExtrasPage.tsx
@@ -20,6 +20,11 @@ import { toast } from 'sonner';
 import ImageUploadButton from '@/components/ImageUploadButton';
 import { fetchUpscalerModels } from "@/services/modelService";
 import { useModelRefresh } from "@/hooks/useModelRefresh";
+import { useExtrasGalleryStore } from '@/stores/useExtrasGalleryStore';
+import { useTxt2ImgGalleryStore } from '@/stores/useTxt2ImgGalleryStore';
+import { useImg2ImgGalleryStore } from '@/stores/useImg2ImgGalleryStore';
+import { ImageResult } from '@/types/generationSettings';
+import { GallerySync } from '@/utils/gallerySync';
 
 const ExtrasPage = () => {
   const [activeSubTab, setActiveSubTab] = useState("upscale");
@@ -29,6 +34,21 @@ const ExtrasPage = () => {
   const [processedImage, setProcessedImage] = useState<string | null>(null);
   const [availableUpscalers, setAvailableUpscalers] = useState([]);
   
+  // Gallery stores for syncing data
+  const { addImages: addExtrasImages } = useExtrasGalleryStore();
+  const txt2imgImages = useTxt2ImgGalleryStore(state => state.images);
+  const img2imgImages = useImg2ImgGalleryStore(state => state.images);
+
+  // Load existing data on component mount
+  useEffect(() => {
+    const loadExistingData = async () => {
+      console.log('📥 Extras: Loading existing gallery data from backend...');
+      await GallerySync.syncFromBackend();
+    };
+    
+    loadExistingData();
+  }, []);
+  
   // New state for advanced upscaling options
   const [upscaleMethod, setUpscaleMethod] = useState("upscale-by");
   const [upscaleFactor, setUpscaleFactor] = useState(2.5);
@@ -205,6 +225,33 @@ const ExtrasPage = () => {
 
       if (result.status === 'success' && result.data) {
         setProcessedImage(result.data.output_image);
+        
+        // Add to extras gallery store
+        const extrasImageResult: ImageResult = {
+          id: `extras_${Date.now()}`,
+          url: result.data.output_image,
+          prompt: `Upscaled with ${selectedUpscaler}`,
+          negativePrompt: '',
+          timestamp: Date.now(),
+          settings: {
+            model_name: selectedUpscaler,
+            sampler_name: 'extras',
+            steps: 1,
+            cfg_scale: 1.0,
+            width: upscaleMethod === 'upscale-to' ? resizeWidth : 512 * upscaleFactor,
+            height: upscaleMethod === 'upscale-to' ? resizeHeight : 512 * upscaleFactor,
+            seed: -1,
+            batch_size: 1,
+            upscale_factor: upscaleFactor,
+            upscale_method: upscaleMethod
+          }
+        };
+        
+        console.log('🖼️ Adding extras image to gallery:', extrasImageResult);
+        
+        // Use centralized sync to add images and sync to backend
+        await GallerySync.addImageAndSync('extras', [extrasImageResult]);
+        
         toast.success("Image processed successfully!");
       } else {
         throw new Error(result.message || 'Failed to process image');
diff --git a/dream_layer_frontend/src/features/Img2Img/Img2ImgPage.tsx b/dream_layer_frontend/src/features/Img2Img/Img2ImgPage.tsx
index e3b29213..a70fb53f 100644
--- a/dream_layer_frontend/src/features/Img2Img/Img2ImgPage.tsx
+++ b/dream_layer_frontend/src/features/Img2Img/Img2ImgPage.tsx
@@ -12,7 +12,10 @@ import OutputQuantity from '@/components/OutputQuantity';
 import GenerationID from '@/components/GenerationID';
 import ImagePreview from '@/components/tabs/img2img/ImagePreview';
 import { useImg2ImgGalleryStore } from '@/stores/useImg2ImgGalleryStore';
+import { useTxt2ImgGalleryStore } from '@/stores/useTxt2ImgGalleryStore';
+import { useExtrasGalleryStore } from '@/stores/useExtrasGalleryStore';
 import useLoraStore from '@/stores/useLoraStore';
+import { GallerySync } from '@/utils/gallerySync';
 import useControlNetStore from '@/stores/useControlNetStore';
 import { ControlNetRequest } from '@/types/controlnet';
 import { prepareControlNetForAPI, validateControlNetConfig } from '@/utils/controlnetUtils';
@@ -60,6 +63,19 @@ const Img2ImgPage: React.FC<Img2ImgPageProps> = ({ selectedModel, onTabChange })
   } = useImg2ImgGalleryStore();
   const selectedLora = useLoraStore(state => state.loraConfig);
   const { controlNetConfig, setControlNetConfig } = useControlNetStore();
+  const txt2imgImages = useTxt2ImgGalleryStore(state => state.images);
+  const img2imgImages = useImg2ImgGalleryStore(state => state.images);
+  const extrasImages = useExtrasGalleryStore(state => state.images);
+
+  // Load existing data on component mount
+  useEffect(() => {
+    const loadExistingData = async () => {
+      console.log('📥 Img2Img: Loading existing gallery data from backend...');
+      await GallerySync.syncFromBackend();
+    };
+    
+    loadExistingData();
+  }, []);
   
   useEffect(() => {
     setIsLoaded(true);
@@ -171,7 +187,7 @@ const Img2ImgPage: React.FC<Img2ImgPageProps> = ({ selectedModel, onTabChange })
         const testImage = new Image();
         const firstImageUrl = data.generated_images[0].url;
         
-        testImage.onload = () => {
+        testImage.onload = async () => {
           console.log('Test image loaded successfully:', firstImageUrl);
           const images = data.generated_images.map((img: any) => ({
             id: `${Date.now()}-${Math.random()}`,
@@ -183,7 +199,10 @@ const Img2ImgPage: React.FC<Img2ImgPageProps> = ({ selectedModel, onTabChange })
           }));
           
           console.log('Adding images to store:', images);
-          addImages(images);
+          
+          // Use centralized sync to add images and sync to backend
+          await GallerySync.addImageAndSync('img2img', images);
+          
           setLoading(false);
           setIsGenerating(false);
         };
diff --git a/dream_layer_frontend/src/features/Txt2Img/Txt2ImgPage.tsx b/dream_layer_frontend/src/features/Txt2Img/Txt2ImgPage.tsx
index cbcc7ee5..f765127b 100644
--- a/dream_layer_frontend/src/features/Txt2Img/Txt2ImgPage.tsx
+++ b/dream_layer_frontend/src/features/Txt2Img/Txt2ImgPage.tsx
@@ -17,7 +17,10 @@ import { Copy } from "lucide-react";
 import { Button } from "@/components/ui/button";
 import { cn } from "@/lib/utils";
 import { useTxt2ImgGalleryStore } from '@/stores/useTxt2ImgGalleryStore';
+import { useImg2ImgGalleryStore } from '@/stores/useImg2ImgGalleryStore';
+import { useExtrasGalleryStore } from '@/stores/useExtrasGalleryStore';
 import { Txt2ImgCoreSettings, defaultTxt2ImgSettings } from '@/types/generationSettings';
+import { GallerySync } from '@/utils/gallerySync';
 import useControlNetStore from '@/stores/useControlNetStore';
 import { ControlNetRequest } from '@/types/controlnet';
 import useLoraStore from '@/stores/useLoraStore';
@@ -46,10 +49,23 @@ const Txt2ImgPage: React.FC<Txt2ImgPageProps> = ({ selectedModel, onTabChange })
   const { toast } = useToast();
   const addImages = useTxt2ImgGalleryStore(state => state.addImages);
   const setLoading = useTxt2ImgGalleryStore(state => state.setLoading);
+  const txt2imgImages = useTxt2ImgGalleryStore(state => state.images);
+  const img2imgImages = useImg2ImgGalleryStore(state => state.images);
+  const extrasImages = useExtrasGalleryStore(state => state.images);
   const controlNetConfig = useControlNetStore(state => state.controlNetConfig);
   const { setControlNetConfig } = useControlNetStore();
   const loraConfig = useLoraStore(state => state.loraConfig);
 
+  // Load existing data on component mount
+  useEffect(() => {
+    const loadExistingData = async () => {
+      console.log('📥 Txt2Img: Loading existing gallery data from backend...');
+      await GallerySync.syncFromBackend();
+    };
+    
+    loadExistingData();
+  }, []);
+
   // Add effect to update model when selectedModel prop changes
   useEffect(() => {
     updateCoreSettings({ model_name: selectedModel });
@@ -244,8 +260,10 @@ const Txt2ImgPage: React.FC<Txt2ImgPageProps> = ({ selectedModel, onTabChange })
           };
         });
         
-        console.log('Adding images to gallery:', images);
-        addImages(images);
+        console.log('🖼️ Adding images to gallery:', images);
+        
+        // Use centralized sync to add images and sync to backend
+        await GallerySync.addImageAndSync('txt2img', images);
       } else {
         console.error('No generated_images in response:', data);
         throw new Error('No images were generated');
diff --git a/dream_layer_frontend/src/pages/Index.tsx b/dream_layer_frontend/src/pages/Index.tsx
index a179f273..fb6607d3 100644
--- a/dream_layer_frontend/src/pages/Index.tsx
+++ b/dream_layer_frontend/src/pages/Index.tsx
@@ -11,6 +11,7 @@ import { PNGInfoPage } from '@/features/PNGInfo';
 import { ConfigurationsPage } from '@/features/Configurations';
 import { RunRegistryPage } from '@/features/RunRegistry';
 import { ReportBundlePage } from '@/features/ReportBundle';
+import ReportGenerator from '@/components/ReportGenerator';
 import { useTxt2ImgGalleryStore } from '@/stores/useTxt2ImgGalleryStore';
 import { useImg2ImgGalleryStore } from '@/stores/useImg2ImgGalleryStore';
 
@@ -43,6 +44,8 @@ const Index = () => {
         return <ExtrasPage />;
       case "models":
         return <ModelManagerPage />;
+      case "reports":
+        return <ReportGenerator />;
       case "pnginfo":
         return <PNGInfoPage />;
       case "configurations":
diff --git a/dream_layer_frontend/src/stores/useExtrasGalleryStore.ts b/dream_layer_frontend/src/stores/useExtrasGalleryStore.ts
new file mode 100644
index 00000000..ac42cfb2
--- /dev/null
+++ b/dream_layer_frontend/src/stores/useExtrasGalleryStore.ts
@@ -0,0 +1,34 @@
+import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
+import { ImageResult } from '@/types/generationSettings';
+
+interface ExtrasGalleryState {
+  images: ImageResult[];
+  isLoading: boolean;
+  addImages: (newImages: ImageResult[]) => void;
+  clearImages: () => void;
+  removeImage: (id: string) => void;
+  setLoading: (loading: boolean) => void;
+}
+
+export const useExtrasGalleryStore = create<ExtrasGalleryState>()(
+  persist(
+    (set) => ({
+      images: [],
+      isLoading: false,
+      addImages: (newImages) => set((state) => ({
+        images: [...newImages, ...state.images],
+        isLoading: false
+      })),
+      clearImages: () => set({ images: [], isLoading: false }),
+      removeImage: (id) => set((state) => ({
+        images: state.images.filter(img => img.id !== id)
+      })),
+      setLoading: (loading) => set({ isLoading: loading }),
+    }),
+    {
+      name: 'extras-gallery-storage',
+      partialize: (state) => ({ images: state.images }), // Only persist images, not loading state
+    }
+  )
+);
diff --git a/dream_layer_frontend/src/stores/useImg2ImgGalleryStore.ts b/dream_layer_frontend/src/stores/useImg2ImgGalleryStore.ts
index 739614c0..ed9fa9fb 100644
--- a/dream_layer_frontend/src/stores/useImg2ImgGalleryStore.ts
+++ b/dream_layer_frontend/src/stores/useImg2ImgGalleryStore.ts
@@ -1,4 +1,5 @@
 import { create } from 'zustand';
+import { persist } from 'zustand/middleware';
 import { ImageResult, CoreGenerationSettings, defaultCoreSettings } from '@/types/generationSettings';
 
 interface InputImage {
@@ -28,7 +29,9 @@ interface Img2ImgGalleryState {
   handleAdvancedSettingsChange: (settings: Partial<CoreGenerationSettings>) => void;
 }
 
-export const useImg2ImgGalleryStore = create<Img2ImgGalleryState>((set) => ({
+export const useImg2ImgGalleryStore = create<Img2ImgGalleryState>()(
+  persist(
+    (set) => ({
   images: [],
   isLoading: false,
   inputImage: null,
@@ -113,4 +116,13 @@ export const useImg2ImgGalleryStore = create<Img2ImgGalleryState>((set) => ({
       ...settings
     }
   }))
-}));
+    }),
+    {
+      name: 'img2img-gallery-storage',
+      partialize: (state) => ({ 
+        images: state.images,
+        coreSettings: state.coreSettings 
+      }), // Persist images and settings, not loading state or file objects
+    }
+  )
+);
diff --git a/dream_layer_frontend/src/stores/useTxt2ImgGalleryStore.ts b/dream_layer_frontend/src/stores/useTxt2ImgGalleryStore.ts
index d9ce8c99..ca258921 100644
--- a/dream_layer_frontend/src/stores/useTxt2ImgGalleryStore.ts
+++ b/dream_layer_frontend/src/stores/useTxt2ImgGalleryStore.ts
@@ -1,5 +1,6 @@
 import { create } from 'zustand';
-import { ImageResult } from '@/types/imageResult';
+import { persist } from 'zustand/middleware';
+import { ImageResult } from '@/types/generationSettings';
 
 interface Txt2ImgGalleryState {
   images: ImageResult[];
@@ -10,16 +11,24 @@ interface Txt2ImgGalleryState {
   setLoading: (loading: boolean) => void;
 }
 
-export const useTxt2ImgGalleryStore = create<Txt2ImgGalleryState>((set) => ({
-  images: [],
-  isLoading: false,
-  addImages: (newImages) => set((state) => ({
-    images: [...newImages, ...state.images],
-    isLoading: false
-  })),
-  clearImages: () => set({ images: [], isLoading: false }),
-  removeImage: (id) => set((state) => ({
-    images: state.images.filter(img => img.id !== id)
-  })),
-  setLoading: (loading) => set({ isLoading: loading }),
-}));
+export const useTxt2ImgGalleryStore = create<Txt2ImgGalleryState>()(
+  persist(
+    (set) => ({
+      images: [],
+      isLoading: false,
+      addImages: (newImages) => set((state) => ({
+        images: [...newImages, ...state.images],
+        isLoading: false
+      })),
+      clearImages: () => set({ images: [], isLoading: false }),
+      removeImage: (id) => set((state) => ({
+        images: state.images.filter(img => img.id !== id)
+      })),
+      setLoading: (loading) => set({ isLoading: loading }),
+    }),
+    {
+      name: 'txt2img-gallery-storage',
+      partialize: (state) => ({ images: state.images }), // Only persist images, not loading state
+    }
+  )
+);
diff --git a/dream_layer_frontend/src/utils/gallerySync.ts b/dream_layer_frontend/src/utils/gallerySync.ts
new file mode 100644
index 00000000..99a2c005
--- /dev/null
+++ b/dream_layer_frontend/src/utils/gallerySync.ts
@@ -0,0 +1,185 @@
+import { useTxt2ImgGalleryStore } from '@/stores/useTxt2ImgGalleryStore';
+import { useImg2ImgGalleryStore } from '@/stores/useImg2ImgGalleryStore';
+import { useExtrasGalleryStore } from '@/stores/useExtrasGalleryStore';
+
+/**
+ * Centralized gallery sync utility to ensure data persistence across tabs
+ */
+export class GallerySync {
+  private static readonly BACKEND_URL = 'http://localhost:5002';
+
+  /**
+   * Sync all gallery data to backend
+   */
+  static async syncToBackend(): Promise<boolean> {
+    try {
+      // Get fresh state from all stores
+      const txt2imgImages = useTxt2ImgGalleryStore.getState().images;
+      const img2imgImages = useImg2ImgGalleryStore.getState().images;
+      const extrasImages = useExtrasGalleryStore.getState().images;
+
+      const galleryData = {
+        txt2img: txt2imgImages,
+        img2img: img2imgImages,
+        extras: extrasImages
+      };
+
+      console.log('🔄 Syncing all gallery data to backend:', {
+        txt2imgCount: txt2imgImages.length,
+        img2imgCount: img2imgImages.length,
+        extrasCount: extrasImages.length,
+        totalImages: txt2imgImages.length + img2imgImages.length + extrasImages.length
+      });
+
+      const response = await fetch(`${this.BACKEND_URL}/api/gallery-data`, {
+        method: 'POST',
+        headers: {
+          'Content-Type': 'application/json',
+        },
+        body: JSON.stringify(galleryData)
+      });
+
+      if (response.ok) {
+        console.log('✅ Gallery data synced successfully to backend');
+        return true;
+      } else {
+        console.error('❌ Failed to sync gallery data:', response.statusText);
+        return false;
+      }
+    } catch (error) {
+      console.error('❌ Error syncing gallery data:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Fetch gallery data from backend and update all stores
+   */
+  static async syncFromBackend(): Promise<boolean> {
+    try {
+      const response = await fetch(`${this.BACKEND_URL}/api/gallery-data`, {
+        method: 'GET',
+        headers: { 'Content-Type': 'application/json' }
+      });
+
+      if (response.ok) {
+        const backendData = await response.json();
+        
+        // Update all stores with backend data (without triggering loading states)
+        const txt2imgStore = useTxt2ImgGalleryStore.getState();
+        const img2imgStore = useImg2ImgGalleryStore.getState();
+        const extrasStore = useExtrasGalleryStore.getState();
+
+        // Only update if backend has more recent data
+        if (backendData.txt2img && Array.isArray(backendData.txt2img)) {
+          txt2imgStore.addImages(backendData.txt2img.filter((img: any) => 
+            !txt2imgStore.images.some(existing => existing.id === img.id)
+          ));
+        }
+
+        if (backendData.img2img && Array.isArray(backendData.img2img)) {
+          img2imgStore.addImages(backendData.img2img.filter((img: any) => 
+            !img2imgStore.images.some(existing => existing.id === img.id)
+          ));
+        }
+
+        if (backendData.extras && Array.isArray(backendData.extras)) {
+          extrasStore.addImages(backendData.extras.filter((img: any) => 
+            !extrasStore.images.some(existing => existing.id === img.id)
+          ));
+        }
+
+        console.log('✅ Gallery data synced from backend to stores');
+        return true;
+      } else {
+        console.warn('Could not fetch gallery data from backend');
+        return false;
+      }
+    } catch (error) {
+      console.error('❌ Error fetching gallery data from backend:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Add image to appropriate store and sync to backend
+   */
+  static async addImageAndSync(type: 'txt2img' | 'img2img' | 'extras', images: any[]): Promise<void> {
+    // Add to appropriate store first
+    switch (type) {
+      case 'txt2img':
+        useTxt2ImgGalleryStore.getState().addImages(images);
+        break;
+      case 'img2img':
+        useImg2ImgGalleryStore.getState().addImages(images);
+        break;
+      case 'extras':
+        useExtrasGalleryStore.getState().addImages(images);
+        break;
+    }
+
+    // Wait a bit for state to update, then sync to backend
+    setTimeout(async () => {
+      await this.syncToBackend();
+    }, 100);
+  }
+
+  /**
+   * Clear all data (for after download)
+   */
+  static async clearAll(): Promise<void> {
+    // Clear all stores
+    useTxt2ImgGalleryStore.getState().clearImages();
+    useImg2ImgGalleryStore.getState().clearImages();
+    useExtrasGalleryStore.getState().clearImages();
+
+    // Clear backend
+    await fetch(`${this.BACKEND_URL}/api/gallery-data`, {
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+      },
+      body: JSON.stringify({
+        txt2img: [],
+        img2img: [],
+        extras: []
+      })
+    });
+
+    console.log('🧹 All gallery data cleared');
+  }
+
+  /**
+   * Check if backend is fresh (empty) and sync frontend accordingly
+   * This ensures fresh starts after service restarts
+   */
+  static async ensureFreshStart(): Promise<void> {
+    try {
+      // Check backend status
+      const response = await fetch(`${this.BACKEND_URL}/api/reports/status`, {
+        method: 'GET',
+        headers: { 'Content-Type': 'application/json' }
+      });
+
+      if (response.ok) {
+        const backendStatus = await response.json();
+        
+        // If backend has no images but frontend stores have data, clear frontend
+        const frontendTotal = 
+          useTxt2ImgGalleryStore.getState().images.length +
+          useImg2ImgGalleryStore.getState().images.length +
+          useExtrasGalleryStore.getState().images.length;
+
+        if (backendStatus.total_images === 0 && frontendTotal > 0) {
+          console.log('🧹 Backend is fresh but frontend has old data - clearing frontend stores');
+          useTxt2ImgGalleryStore.getState().clearImages();
+          useImg2ImgGalleryStore.getState().clearImages();
+          useExtrasGalleryStore.getState().clearImages();
+          console.log('✅ Frontend stores cleared for fresh start');
+        }
+      }
+    } catch (error) {
+      console.warn('Could not check backend status for fresh start sync:', error);
+    }
+  }
+}
diff --git a/dream_layer_frontend/src/utils/imageTransfer.ts b/dream_layer_frontend/src/utils/imageTransfer.ts
index 0d2b28f0..c4d4c041 100644
--- a/dream_layer_frontend/src/utils/imageTransfer.ts
+++ b/dream_layer_frontend/src/utils/imageTransfer.ts
@@ -1,5 +1,5 @@
 
-import { ImageResult } from '@/types/imageResult';
+import { ImageResult } from '@/types/generationSettings';
 
 export const transferImages = (
   srcStore: { images: ImageResult[] },
diff --git a/start_dream_layer.sh b/start_dream_layer.sh
index b0b600be..ef834f04 100755
--- a/start_dream_layer.sh
+++ b/start_dream_layer.sh
@@ -176,6 +176,9 @@ main() {
     # Clean up served_images directory
     [ -d "dream_layer_backend/served_images" ] && rm -f dream_layer_backend/served_images/* && print_success "Cleaned up served_images directory"
     
+    # Clear persistent gallery data for fresh start
+    echo '{"txt2img": [], "img2img": [], "extras": []}' > dream_layer_backend/temp_gallery_data.json && print_success "Cleared persistent gallery data"
+    
     # Kill any existing processes on our ports
     print_status "Cleaning up existing processes..."
     kill_port 8188  # ComfyUI