Fixed Mobile support. Added a new AI media detection mechanism by Farid, that creates geometric lines. Fixed logs

backend/app/ai/explanation_engine.py

@@ -19,6 +19,8 @@ def generated_structured_explanation(features: Dict[str, float], prob: float) ->
 
     freq = features.get("frequency_score", 0.0)
     cnn = features.get("cnn_score", 0.0)
+    geometry_score = features.get("geometry_score")
+    geometry_message = features.get("geometry_message")
     
     if freq > 1.5:
         contributions["frequency"] = freq
@@ -34,6 +36,18 @@ def generated_structured_explanation(features: Dict[str, float], prob: float) ->
             "reason": f"CNN artifact score of {cnn:.2f} indicates structural anomalies in bounding edges (Target > 1.0)."
         })
         
+    if geometry_score is not None and geometry_score < 50:
+        contributions["geometry"] = geometry_score
+        region_analysis.append({
+            "region": "Perspective & Structural Lines",
+            "reason": f"Perspective consistency score of {geometry_score:.1f}/100. {geometry_message}"
+        })
+    elif geometry_score is not None and geometry_score >= 75:
+        region_analysis.append({
+            "region": "Perspective & Structural Lines",
+            "reason": f"Perspective consistency score of {geometry_score:.1f}/100. {geometry_message}"
+        })
+        
     if not region_analysis:
         region_analysis.append({
             "region": "Image-Wide",

backend/app/ai/geometry_detector.py

@@ -0,0 +1,152 @@
+import cv2
+import numpy as np
+import math
+import logging
+
+logger = logging.getLogger(__name__)
+
+def line_intersection(line1, line2):
+    """Find the intersection of two lines defined by (x1, y1, x2, y2)."""
+    x1, y1, x2, y2 = line1
+    x3, y3, x4, y4 = line2
+
+    denom = (x1 - x2) * (y3 - y4) - (y1 - y2) * (x3 - x4)
+    if denom == 0:
+        return None # Parallel lines
+
+    px = ((x1 * y2 - y1 * x2) * (x3 - x4) - (x1 - x2) * (x3 * y4 - y3 * x4)) / denom
+    py = ((x1 * y2 - y1 * x2) * (y3 - y4) - (y1 - y2) * (x3 * y4 - y3 * x4)) / denom
+    return (px, py)
+
+def analyze_perspective(image_path: str, output_path: str) -> dict:
+    """
+    Reads an image, detects structural lines, estimates vanishing points/intersections,
+    and returns a geometric consistency score (0-100).
+    Saves an overlay image at output_path.
+    """
+    img = cv2.imread(image_path)
+    if img is None:
+        logger.error(f"Could not read image at {image_path} for perspective analysis")
+        return {"score": None, "message": "Failed to read image"}
+
+    original_h, original_w = img.shape[:2]
+    
+    # Resize for performance and consistent thresholds
+    max_dim = 1024
+    scale = 1.0
+    if max(original_h, original_w) > max_dim:
+        scale = max_dim / max(original_h, original_w)
+        new_w, new_h = int(original_w * scale), int(original_h * scale)
+        process_img = cv2.resize(img, (new_w, new_h))
+    else:
+        process_img = img.copy()
+
+    gray = cv2.cvtColor(process_img, cv2.COLOR_BGR2GRAY)
+    
+    # Adaptive edge detection
+    blur = cv2.GaussianBlur(gray, (5, 5), 0)
+    median_val = np.median(blur)
+    lower = int(max(0, 0.66 * median_val))
+    upper = int(min(255, 1.33 * median_val))
+    edges = cv2.Canny(blur, lower, upper)
+
+    # Line detection (HoughLinesP)
+    min_line_length = max(50, process_img.shape[0] * 0.1)
+    lines = cv2.HoughLinesP(edges, 1, np.pi / 180, threshold=50, minLineLength=min_line_length, maxLineGap=20)
+
+    score = 50.0 # Default neutral
+    message = "Insufficient geometric structure for reliable perspective analysis."
+    intersections = []
+    
+    # Overlay creation
+    overlay = process_img.copy()
+    overlay = cv2.convertScaleAbs(overlay, alpha=0.3, beta=0) # Darken original image
+    
+    # Color definitions (BGR)
+    COLOR_LINE = (200, 200, 200) # Subtle white/gray for lines
+    COLOR_COHERENT = (200, 255, 100) # Cyan/Greenish
+    COLOR_INCOHERENT = (50, 100, 255) # Amber/Reddish
+
+    if lines is not None and len(lines) >= 4:
+        # Filter lines to remove strictly horizontal/vertical (which don't converge to distant VPs well)
+        filtered_lines = []
+        for line in lines:
+            x1, y1, x2, y2 = line[0]
+            angle = math.degrees(math.atan2(y2 - y1, x2 - x1))
+            angle = abs(angle) % 180
+            # Keep lines that are somewhat diagonal
+            if (10 < angle < 80) or (100 < angle < 170):
+                filtered_lines.append(line[0])
+                
+        if len(filtered_lines) >= 4:
+            # Limit to top 50 lines to avoid combinatorial explosion
+            filtered_lines = filtered_lines[:50]
+            
+            # Find pairwise intersections
+            for i in range(len(filtered_lines)):
+                for j in range(i + 1, len(filtered_lines)):
+                    pt = line_intersection(filtered_lines[i], filtered_lines[j])
+                    if pt is not None:
+                        # Only keep intersections that are somewhat reasonable (not infinite)
+                        if -process_img.shape[1]*2 < pt[0] < process_img.shape[1]*3 and \
+                           -process_img.shape[0]*2 < pt[1] < process_img.shape[0]*3:
+                            intersections.append(pt)
+
+    status_color = COLOR_LINE
+    if len(intersections) > 5:
+        # Calculate cluster coherence (Median Absolute Deviation of intersections)
+        pts = np.array(intersections)
+        median_pt = np.median(pts, axis=0)
+        distances = np.linalg.norm(pts - median_pt, axis=1)
+        mad = np.median(distances)
+        
+        # Normalize MAD by image diagonal
+        diagonal = math.sqrt(process_img.shape[0]**2 + process_img.shape[1]**2)
+        relative_dispersion = mad / diagonal
+        
+        # Score mapping:
+        # relative_dispersion < 0.05 -> very coherent (score 90+)
+        # relative_dispersion > 0.25 -> very incoherent (score < 40)
+        # Using an exponential decay mapping to score
+        score = max(10, min(100, 100 * math.exp(-relative_dispersion * 5)))
+        
+        if score >= 75:
+            message = "Perspective geometry appears physically coherent with a common vanishing-point structure."
+            status_color = COLOR_COHERENT
+        else:
+            message = "Structural perspective lines show inconsistent convergence behavior, which may indicate synthetic image generation."
+            status_color = COLOR_INCOHERENT
+            
+        # Draw all lines
+        for x1, y1, x2, y2 in filtered_lines:
+            cv2.line(overlay, (x1, y1), (x2, y2), status_color, 1, cv2.LINE_AA)
+            
+        # Draw intersections (dots)
+        for pt in intersections:
+            cv2.circle(overlay, (int(pt[0]), int(pt[1])), 2, status_color, -1)
+            
+        # Draw median point
+        cv2.circle(overlay, (int(median_pt[0]), int(median_pt[1])), 8, (255, 255, 255), 2, cv2.LINE_AA)
+
+    else:
+        # Not enough lines/intersections
+        score = None
+
+    # Add text overlay
+    if score is not None:
+        cv2.putText(overlay, f"Perspective Consistency: {score:.1f}/100", (20, 40), 
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.7, status_color, 2, cv2.LINE_AA)
+    else:
+        cv2.putText(overlay, "Perspective: Insufficient Geometry", (20, 40), 
+                    cv2.FONT_HERSHEY_SIMPLEX, 0.7, (150, 150, 150), 2, cv2.LINE_AA)
+
+    # Resize back to original
+    if scale != 1.0:
+        overlay = cv2.resize(overlay, (original_w, original_h))
+
+    cv2.imwrite(output_path, overlay)
+    
+    return {
+        "score": score,
+        "message": message
+    }

backend/app/api/file_routes.py

@@ -42,6 +42,8 @@ def format_file_response(f):
         "filename": f.filename,
         "filepath": active_storage.get_presigned_url(f.filepath) if f.filepath else None,
         "heatmap_path": active_storage.get_presigned_url(f.heatmap_path) if f.heatmap_path else None,
+        "geometry_path": active_storage.get_presigned_url(f.geometry_path) if getattr(f, "geometry_path", None) else None,
+        "geometry_score": getattr(f, "geometry_score", None),
         "type": f.filetype,
         "size": f.filesize,
         "status": f.status,

backend/app/core/logger.py

@@ -1,47 +1,64 @@
 import sys
 import os
-import requests as _requests
 from loguru import logger
 from app.core.config import settings
 from pathlib import Path
 from app.core.request_id import get_request_id
 
-# 1. Clean up default loguru handler
+# ── 1. Remove default loguru handler ──────────────────────────────────────────
 logger.remove()
 
-# 2. Inject the request ID into loguru's "extra" dictionary globally
-def inject_request_id(record):
+# ── 2. Inject request_id into every log record ───────────────────────────────
+def _inject_request_id(record):
     req_id = get_request_id()
     record["extra"]["request_id"] = req_id if req_id else "SYSTEM"
 
-logger.configure(patcher=inject_request_id)
+logger.configure(patcher=_inject_request_id)
 
-# 3. Create log directory
+# ── 3. Log directory ──────────────────────────────────────────────────────────
 log_dir = Path("app_logs")
 log_dir.mkdir(parents=True, exist_ok=True)
 
-# 4. Console Logger (JSON Serialized)
-logger.add(
-    sys.stdout,
-    format="{message}",
-    serialize=True,
-    level=settings.LOG_LEVEL,
-    enqueue=True
-)
+# ── 4. Console — structured JSON for production, colorized text for local ─────
+IS_PROD = os.environ.get("ENVIRONMENT", "development").lower() in ("production", "prod")
+
+if IS_PROD:
+    # Production: pure JSON, machine-readable — timestamp in 12-hour AM/PM UTC
+    logger.add(
+        sys.stdout,
+        format="{message}",
+        serialize=True,   # emits {"text":..., "record":{...}} JSON lines
+        level=settings.LOG_LEVEL,
+        enqueue=True,
+    )
+else:
+    # Local dev: human-readable with color, 12-hour AM/PM format
+    logger.add(
+        sys.stdout,
+        format=(
+            "<green>{time:MM-DD-YYYY hh:mm:ss A}</green> | "
+            "<level>{level:<8}</level> | "
+            "<cyan>[{extra[request_id]}]</cyan> "
+            "<white>{name}:{function}:{line}</white> — {message}"
+        ),
+        colorize=True,
+        level=settings.LOG_LEVEL,
+        enqueue=True,
+    )
 
-# 5. File Logger
+# ── 5. File logger — 12-hour AM/PM timestamp ─────────────────────────────────
 logger.add(
     "app_logs/api_{time:YYYY-MM-DD}.log",
     rotation="00:00",
     retention="30 days",
     compression="zip",
     level="INFO",
-    format="{time:YYYY-MM-DD HH:mm:ss} | {level} | [{extra[request_id]}] {name}:{function}:{line} - {message}",
-    enqueue=True
+    # hh = 12-hour clock, A = AM/PM
+    format="{time:MM-DD-YYYY hh:mm:ss A} | {level:<8} | [{extra[request_id]}] {name}:{function}:{line} — {message}",
+    enqueue=True,
 )
 
-# 6. New Relic Cloud Sink (fully optional — never crashes the app)
-#    Set NEW_RELIC_LICENSE_KEY and NEW_RELIC_APP_NAME in your environment.
+# ── 6. New Relic sink (optional — never crashes the app) ──────────────────────
 _NR_KEY = os.environ.get("NEW_RELIC_LICENSE_KEY", "")
 if _NR_KEY:
     try:
@@ -54,25 +71,26 @@ if _NR_KEY:
         def _newrelic_sink(message):
             record = message.record
             try:
-                # Send to New Relic Logs APM
                 newrelic.agent.record_log_event(
                     message=record["message"],
                     level=record["level"].name,
                     timestamp=int(record["time"].timestamp() * 1000),
                     attributes={
                         "request_id": record["extra"].get("request_id", "SYSTEM"),
-                        "logger": record["name"],
-                        "function": record["function"],
-                        "line": record["line"],
+                        "method":     record["extra"].get("method", ""),
+                        "path":       record["extra"].get("path", ""),
+                        "status":     record["extra"].get("status", ""),
+                        "duration_ms": record["extra"].get("duration_ms", ""),
+                        "logger":     record["name"],
+                        "function":   record["function"],
+                        "line":       record["line"],
                     }
                 )
             except Exception:
-                pass  # Never let cloud logging failure affect the app
+                pass  # Cloud logging must never affect the app
 
         logger.add(_newrelic_sink, level="INFO", enqueue=True)
     except ImportError:
-        # newrelic package not installed — skip silently
         pass
     except Exception:
-        # Any other error during setup — skip silently
         pass

backend/app/core/logging_middleware.py

@@ -1,33 +1,49 @@
 import time
+import os
 from fastapi import Request
 from starlette.middleware.base import BaseHTTPMiddleware
 from app.core.logger import logger
-from app.core.request_id import generate_request_id
+
+# Paths that are too noisy to log at INFO — only log if they error
+_QUIET_PATHS = frozenset(["/health", "/favicon.ico", "/metrics", "/docs", "/openapi.json", "/redoc"])
 
 class APILoggingMiddleware(BaseHTTPMiddleware):
     async def dispatch(self, request: Request, call_next):
-        req_id = generate_request_id()
-        start_time = time.time()
+        start_time = time.perf_counter()
+        path = request.url.path
+        method = request.method
 
-        logger.info(f"Incoming Request: {request.method} {request.url.path}")
         try:
             response = await call_next(request)
-            process_time = time.time() - start_time
+        except Exception as exc:
+            duration_ms = round((time.perf_counter() - start_time) * 1000, 1)
+            logger.bind(
+                method=method,
+                path=path,
+                status=500,
+                duration_ms=duration_ms,
+            ).error(f"Unhandled exception on {method} {path} — {type(exc).__name__}: {exc}")
+            raise
 
-            logger.info(
-                f"Request Completed: {request.method} {request.url.path} "
-                f"- Status: {response.status_code} "
-                f"in {process_time:.4f}s"
-            )
+        duration_ms = round((time.perf_counter() - start_time) * 1000, 1)
+        status = response.status_code
 
-            response.headers["X-Request-ID"] = req_id
+        # Suppress noisy health-check / static paths unless they error
+        if path in _QUIET_PATHS and status < 400:
             return response
-            
-        except Exception as exc:
-            process_time = time.time() - start_time
-            logger.error(
-                f"Request Failed: {request.method} {request.url.path} "
-                f"- Error: {str(exc)} "
-                f"in {process_time:.4f}s"
-            )
-            raise
+
+        # Route logs by severity so production dashboards can filter cleanly
+        bound = logger.bind(method=method, path=path, status=status, duration_ms=duration_ms)
+
+        if status >= 500:
+            bound.error(f"{method} {path} → {status} ({duration_ms}ms)")
+        elif status >= 400:
+            # 401 on /auth/me is expected background noise — demote to DEBUG
+            if path == "/auth/me" and status == 401:
+                bound.debug(f"{method} {path} → {status} ({duration_ms}ms)")
+            else:
+                bound.warning(f"{method} {path} → {status} ({duration_ms}ms)")
+        else:
+            bound.info(f"{method} {path} → {status} ({duration_ms}ms)")
+
+        return response

backend/app/core/processor.py

@@ -14,6 +14,7 @@ from app.ai.feature_extractor import extract_features
 from app.ai.attribution import generate_attribution
 from app.ai.explanation_engine import generated_structured_explanation
 from app.ai.explanation_formatter import format_explanation_with_llm
+from app.ai.geometry_detector import analyze_perspective
 from app.core.storage import active_storage
 import os
 
@@ -27,8 +28,10 @@ def process_file(file_id: int, db: Session):
     local_path = active_storage.download_to_temp(file.filepath)
 
     safe_heatmap_name = f"{uuid.uuid4().hex}.png"
+    safe_geometry_name = f"geom_{uuid.uuid4().hex}.png"
     os.makedirs("uploads/heatmaps", exist_ok=True)
     local_heatmap_path = f"uploads/heatmaps/{safe_heatmap_name}"
+    local_geometry_path = f"uploads/heatmaps/{safe_geometry_name}"
     
     file.status = "PROCESSING"
     active_version = model_loader.get_latest_model_version()
@@ -41,6 +44,11 @@ def process_file(file_id: int, db: Session):
         label, prob = predict_ai(features["frequency_score"], features["cnn_score"])
         attribution_data = generate_attribution(local_path, local_heatmap_path)
         
+        # Geometry Perspective Analysis
+        geom_result = analyze_perspective(local_path, local_geometry_path)
+        features["geometry_score"] = geom_result["score"]
+        features["geometry_message"] = geom_result["message"]
+        
         class MockFile:
             def __init__(self, f):
                 self.file = f
@@ -50,7 +58,15 @@ def process_file(file_id: int, db: Session):
             mock_hf = MockFile(hf)
             r2_heatmap_key = active_storage.save(mock_hf, f"heatmaps/{safe_heatmap_name}")
             
+        if os.path.exists(local_geometry_path):
+            with open(local_geometry_path, "rb") as gf:
+                mock_gf = MockFile(gf)
+                r2_geometry_key = active_storage.save(mock_gf, f"heatmaps/{safe_geometry_name}")
+            file.geometry_path = r2_geometry_key
+        
+        file.geometry_score = geom_result["score"]
         file.heatmap_path = r2_heatmap_key
+        
         structured_reasoning = generated_structured_explanation(features, prob)
         natural_reasoning = format_explanation_with_llm(structured_reasoning)
             
@@ -68,6 +84,8 @@ def process_file(file_id: int, db: Session):
             os.remove(local_path)
         if 'local_heatmap_path' in locals() and os.path.exists(local_heatmap_path):
             os.remove(local_heatmap_path)
+        if 'local_geometry_path' in locals() and os.path.exists(local_geometry_path):
+            os.remove(local_geometry_path)
             
     db.commit()
     db.close()

backend/app/models/file_model.py

@@ -11,6 +11,8 @@ class File(Base):
     filetype = Column(String, nullable=False)
     filesize = Column(Integer, nullable=False)
     heatmap_path = Column(String, nullable=True)
+    geometry_path = Column(String, nullable=True)
+    geometry_score = Column(Float, nullable=True)
     timeline_data = Column(String, nullable=True)
     ip_address = Column(String, nullable=True)
     

backend/app/worker/celery_app.py

@@ -1,16 +1,28 @@
+import ssl
 from celery import Celery
 from app.core.config import settings
 
 redis_url = settings.REDIS_URL
-if redis_url.startswith("rediss://") and "ssl_cert_reqs=" not in redis_url:
-    delimiter = "&" if "?" in redis_url else "?"
-    redis_url = f"{redis_url}{delimiter}ssl_cert_reqs=CERT_NONE"
+
+# SSL configuration for production Redis (Upstash / Redis Cloud / etc.)
+# We use proper cert verification instead of the insecure CERT_NONE override.
+_broker_ssl = None
+_backend_ssl = None
+
+if redis_url.startswith("rediss://"):
+    # CERT_REQUIRED with the system CA bundle — correct for managed Redis providers
+    _ssl_opts = {
+        "ssl_cert_reqs": ssl.CERT_REQUIRED,
+        "ssl_ca_certs": ssl.get_default_verify_paths().cafile,  # system CA bundle
+    }
+    _broker_ssl = _ssl_opts
+    _backend_ssl = _ssl_opts
 
 celery_app = Celery(
     "worker",
     broker=redis_url,
     backend=redis_url,
-    include=["app.worker.tasks"]
+    include=["app.worker.tasks"],
 )
 
 celery_app.conf.update(
@@ -19,4 +31,7 @@ celery_app.conf.update(
     result_serializer="json",
     timezone="UTC",
     enable_utc=True,
+    # Apply SSL config only when connecting to rediss:// endpoints
+    broker_use_ssl=_broker_ssl,
+    redis_backend_use_ssl=_backend_ssl,
 )

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

@@ -21,6 +21,8 @@ interface FileResult {
     uploaded_at: string;
     confidence?: number;
     ai_explanation?: string;
+    geometry_path?: string | null;
+    geometry_score?: number | null;
 }
 
 export default function ResultPage() {
@@ -39,6 +41,7 @@ export default function ResultPage() {
     const [isUploadModalOpen, setIsUploadModalOpen] = useState(false);
     const [mediaLoaded, setMediaLoaded] = useState(false);
     const [heatmapLoaded, setHeatmapLoaded] = useState(false);
+    const [showGeometryLayer, setShowGeometryLayer] = useState(false);
     
     // Feedback States
     const [showFeedbackPopup, setShowFeedbackPopup] = useState(false);
@@ -132,11 +135,13 @@ export default function ResultPage() {
 
     let mediaUrl = "";
     let heatmapUrl: string | null = null;
+    let geometryUrl: string | null = null;
     let label = 'AUTHENTIC';
     let verdictStatus: 'AI' | 'SUSPICIOUS' | 'REAL' = 'REAL';
     let confidenceVal: number | null = null;
     let freqScore: number | null = null;
     let cnnScore: number | null = null;
+    let geometryScore: number | null = null;
     let nsfwScore: number | string | null = null;
 
     if (fileData) {
@@ -170,6 +175,20 @@ export default function ResultPage() {
             }
         }
         
+        if (fileData.geometry_path) {
+            if (fileData.geometry_path.startsWith('http://') || fileData.geometry_path.startsWith('https://')) {
+                geometryUrl = fileData.geometry_path;
+            } else {
+                const gp = fileData.geometry_path.replace(/\\/g, '/');
+                const match = gp.match(/uploads[/].*$/);
+                if (match) {
+                    geometryUrl = `http://localhost:8000/static/${match[0]}`;
+                } else {
+                    geometryUrl = `http://localhost:8000/static/${gp.startsWith('/') ? gp.slice(1) : gp}`;
+                }
+            }
+        }
+
         if (fileData.result) {
             const parts = fileData.result.split(/\r?\n/);
             const rawLabel = parts[0].trim();
@@ -198,6 +217,7 @@ export default function ResultPage() {
             if (nsfwMatch) nsfwScore = isNaN(parseFloat(nsfwMatch[1])) ? nsfwMatch[1] : parseFloat(nsfwMatch[1]);
         }
         confidenceVal = fileData.confidence ?? null;
+        geometryScore = fileData.geometry_score ?? null;
     }
 
     // Dynamic Tag Extractor
@@ -357,7 +377,7 @@ export default function ResultPage() {
                                 />
                                 
                                 {/* Heatmap Overlay (Clipped) */}
-                                {heatmapUrl && (
+                                {heatmapUrl && !showGeometryLayer && (
                                     <img 
                                         src={heatmapUrl} 
                                         alt="Heatmap/Noise Pattern" 
@@ -367,6 +387,16 @@ export default function ResultPage() {
                                     />
                                 )}
 
+                                {/* Geometry Overlay (Clipped) */}
+                                {geometryUrl && showGeometryLayer && (
+                                    <img 
+                                        src={geometryUrl} 
+                                        alt="Perspective Geometry" 
+                                        className="absolute inset-0 w-full h-full object-contain !cursor-none z-20 pointer-events-none mix-blend-screen" 
+                                        style={{ clipPath: `inset(0 ${100 - sliderValue}% 0 0)` }}
+                                    />
+                                )}
+
                                 {/* Slider Divider Line */}
                                 {heatmapUrl && (
                                     <div 
@@ -378,7 +408,7 @@ export default function ResultPage() {
                                 )}
 
                                 {/* Interactive Invisible Slider */}
-                                {heatmapUrl && (
+                                {(heatmapUrl || geometryUrl) && (
                                     <input 
                                         type="range"
                                         min="0"
@@ -394,6 +424,28 @@ export default function ResultPage() {
                         {/* Scanline overlay */}
                         <div className="pointer-events-none absolute inset-0 opacity-[0.05] mix-blend-overlay z-50" style={{ background: 'repeating-linear-gradient(0deg, transparent, transparent 2px, #fff 2px, #fff 4px)' }}></div>
                     </div>
+
+                    {/* Layer Toggles */}
+                    {!isVideo && (heatmapUrl || geometryUrl) && (
+                        <div className="flex gap-4 items-center justify-center mt-2">
+                            {heatmapUrl && (
+                                <button 
+                                    onClick={() => setShowGeometryLayer(false)}
+                                    className={`px-4 py-2 rounded-full text-xs font-bold uppercase tracking-widest transition-all ${!showGeometryLayer ? 'bg-[var(--theme-text)] text-[var(--theme-bg)] shadow-[0_0_15px_rgba(253,232,214,0.3)]' : 'bg-transparent border border-[var(--theme-border)] text-[var(--theme-text)]/70 hover:text-[var(--theme-text)]'}`}
+                                >
+                                    Noise Heatmap
+                                </button>
+                            )}
+                            {geometryUrl && (
+                                <button 
+                                    onClick={() => setShowGeometryLayer(true)}
+                                    className={`px-4 py-2 rounded-full text-xs font-bold uppercase tracking-widest transition-all ${showGeometryLayer ? 'bg-[var(--theme-text)] text-[var(--theme-bg)] shadow-[0_0_15px_rgba(253,232,214,0.3)]' : 'bg-transparent border border-[var(--theme-border)] text-[var(--theme-text)]/70 hover:text-[var(--theme-text)]'}`}
+                                >
+                                    Perspective Geometry
+                                </button>
+                            )}
+                        </div>
+                    )}
                 </div>
 
                 {/* Right Side: Analysis */}
@@ -421,7 +473,7 @@ export default function ResultPage() {
                             }`}>
                                 Analysis Verdict
                             </span>
-                            <h1 className="text-5xs md:text-6xl font-black tracking-tight text-[var(--theme-text)] my-2">
+                            <h1 className="text-4xl md:text-6xl font-black tracking-tight text-[var(--theme-text)] my-2">
                                 {label}
                             </h1>
                             {confidenceVal !== null && (
@@ -478,7 +530,26 @@ export default function ResultPage() {
                             </div>
                         </div>
 
-                        <div className="upload-glass p-6 rounded-2xl flex flex-col gap-4 !cursor-none md:col-span-2 relative overflow-hidden group">
+                        {geometryScore !== null && (
+                            <div className="upload-glass p-6 rounded-2xl flex flex-col gap-4 !cursor-none relative overflow-hidden group">
+                                <div className="absolute top-0 left-0 w-full h-[1px] bg-gradient-to-r from-transparent via-[var(--theme-border)]/30 to-transparent transform -translate-x-full group-hover:translate-x-full transition-transform duration-1000 delay-200"></div>
+                                <div className="p-2 bg-[var(--theme-text)]/10 w-10 h-10 flex items-center justify-center rounded-lg border border-[var(--theme-border)]">
+                                    <svg className="w-5 h-5 text-[var(--theme-text)]" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+                                        <path strokeLinecap="round" strokeLinejoin="round" strokeWidth={2} d="M14 10l-2 1m0 0l-2-1m2 1v2.5M20 7l-2 1m2-1l-2-1m2 1v2.5M14 4l-2-1-2 1M4 7l2-1M4 7l2 1M4 7v2.5M12 21l-2-1m2 1l2-1m-2 1v-2.5M6 18l-2-1v-2.5M18 18l2-1v-2.5" />
+                                    </svg>
+                                </div>
+                                <div>
+                                    <h4 className="text-[var(--theme-text)] font-bold text-lg mb-1">Perspective Consistency</h4>
+                                    <p className="text-[#d0c4bb] text-xs leading-relaxed opacity-80 mb-3">Mathematical vanishing-point coherence. Low score means physics-defying structural lines.</p>
+                                    <div className="flex items-end gap-2">
+                                        <span className={`text-2xl font-mono ${geometryScore >= 75 ? 'text-emerald-400/90' : 'text-amber-400/90'}`}>{geometryScore.toFixed(1)}</span>
+                                        <span className="text-[10px] uppercase tracking-widest opacity-40 mb-1 leading-none">/100</span>
+                                    </div>
+                                </div>
+                            </div>
+                        )}
+
+                        <div className={`upload-glass p-6 rounded-2xl flex flex-col gap-4 !cursor-none ${geometryScore !== null ? 'md:col-span-1' : 'md:col-span-2'} relative overflow-hidden group`}>
                              <div className="absolute top-0 left-0 w-full h-[1px] bg-gradient-to-r from-transparent via-[var(--theme-border)]/30 to-transparent transform -translate-x-full group-hover:translate-x-full transition-transform duration-1000 delay-200"></div>
                             <Hash className="w-6 h-6 text-[var(--theme-text)] opacity-80" />
                             <div>

frontend/components/upload/UploadZone.tsx

@@ -79,8 +79,18 @@ export default function UploadZone({ autoAnalyze = false }: { autoAnalyze?: bool
             setUploadedFileId(fileId);
 
             let polling = true;
-            const pollInterval = setInterval(async () => {
+            let pollCount = 0;
+            let timeoutId: NodeJS.Timeout;
+
+            const pollStatus = async () => {
                 if (!polling) return;
+
+                // Pause polling if tab is in the background
+                if (document.hidden) {
+                    timeoutId = setTimeout(pollStatus, 2000);
+                    return;
+                }
+
                 try {
                     const baseUrl = process.env.NEXT_PUBLIC_BACKEND_URL || "http://localhost:8000";
                     const statusRes = await axios.get(`${baseUrl}/files/${fileId}`, {
@@ -91,7 +101,6 @@ export default function UploadZone({ autoAnalyze = false }: { autoAnalyze?: bool
                     
                     if (fileData.status === 'Completed' || fileData.status === 'completed' || fileData.result || fileData.status === 'COMPLETED') {
                         polling = false;
-                        clearInterval(pollInterval);
                         clearInterval(fakeProgressInterval);
                         
                         setProcessProgress(100);
@@ -123,17 +132,48 @@ export default function UploadZone({ autoAnalyze = false }: { autoAnalyze?: bool
                                 notifAudioRef.current.play().catch(e => console.warn("Audio play failed:", e));
                             }
                         }, 400);
+                        return;
                     } else if (fileData.status === 'Failed' || fileData.status === 'error' || fileData.status === 'FAILED') {
                         polling = false;
-                        clearInterval(pollInterval);
                         clearInterval(fakeProgressInterval);
                         setError("Analysis failed on the server.");
                         setInteractionState('upload');
+                        return;
                     }
                 } catch (e) {
                     console.error("Polling error", e);
                 }
-            }, 2000);
+
+                // Exponential backoff logic
+                pollCount++;
+                let nextInterval = 2000; // First 15s (approx 7 polls)
+                if (pollCount > 20) {
+                    nextInterval = 10000; // After 45s, poll every 10s
+                } else if (pollCount > 7) {
+                    nextInterval = 5000; // After 15s, poll every 5s
+                }
+                
+                if (pollCount > 40) { // Max out around 4 mins
+                    polling = false;
+                    clearInterval(fakeProgressInterval);
+                    setError("Analysis timed out. Please try again later.");
+                    setInteractionState('upload');
+                    return;
+                }
+
+                timeoutId = setTimeout(pollStatus, nextInterval);
+            };
+
+            // Start polling
+            pollStatus();
+
+            // Cleanup function for useEffect unmount
+            const cleanup = () => {
+                polling = false;
+                if (timeoutId) clearTimeout(timeoutId);
+                clearInterval(fakeProgressInterval);
+            };
+            (window as any)._currentUploadCleanup = cleanup;
 
         } catch (err: any) {
             clearInterval(fakeProgressInterval);
@@ -158,6 +198,10 @@ export default function UploadZone({ autoAnalyze = false }: { autoAnalyze?: bool
     useEffect(() => {
         return () => {
             if (mediaPreviewUrl) URL.revokeObjectURL(mediaPreviewUrl);
+            if ((window as any)._currentUploadCleanup) {
+                (window as any)._currentUploadCleanup();
+                delete (window as any)._currentUploadCleanup;
+            }
         };
     }, [mediaPreviewUrl]);
 

frontend/contexts/AuthContext.tsx

@@ -1,6 +1,7 @@
 "use client";
-import React, { createContext, useContext, useState, useEffect } from 'react';
-import { useRouter, usePathname } from 'next/navigation';
+import React, { createContext, useContext, useState, useEffect, useRef } from 'react';
+import { usePathname } from 'next/navigation';
+import { useRouter } from 'next/navigation';
 import { apiLayer } from '@/lib/api';
 
 type UserData = {
@@ -28,12 +29,17 @@ export function AuthProvider({ children }: { children: React.ReactNode }) {
   const [user, setUser] = useState<UserData | null>(null);
   const [loading, setLoading] = useState(true);
   
+  // Guard against double-execution in React StrictMode / Next.js App Router
+  // (router from useRouter() gets a new identity on every render, so we NEVER
+  //  put it in the dep array — we check auth exactly once on mount)
+  const hasFetched = useRef(false);
   const router = useRouter();
+  const pathname = usePathname();
 
   useEffect(() => {
-    // Only check if we are not on a public unprotected path unless it's specifically standard.
-    // Dashboard strictly requires validation.
-    
+    if (hasFetched.current) return;
+    hasFetched.current = true;
+
     setLoading(true);
     apiLayer.getCurrentUser()
       .then((res) => {
@@ -43,20 +49,23 @@ export function AuthProvider({ children }: { children: React.ReactNode }) {
       .catch(() => {
         setIsAuthenticated(false);
         setUser(null);
-        // Explicitly guard the dashboard
-        if (window.location.pathname.includes('/dashboard')) {
+        // Only redirect to login from protected routes
+        if (pathname?.includes('/dashboard') || pathname?.includes('/profile')) {
           router.push('/login');
         }
       })
       .finally(() => {
         setLoading(false);
       });
-  }, [router]);
+  // Empty deps: intentional. Auth is checked once on mount, never on re-render.
+  // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, []);
 
   const logout = () => {
     localStorage.removeItem("access_token");
     setIsAuthenticated(false);
     setUser(null);
+    hasFetched.current = false; // Allow re-check after logout
     router.push("/login");
   };