fix(wave9): 10 P0 prod bugs from 5-agent audit

Backend:
- main.py _process_sync: per-image try/except; single failure no longer
aborts entire batch (was returning 500 on N>=2 photos with custom model).
- main.py update_inspection: model_versions added to JSONB column list,
was silently dropping every completed inspect's model metadata.
- ml_service.py check_model_files_available: fix REGISTRY ImportError
(symbol does not exist; use get_registry() public API).
- ml_service.py _analyze_via_roboflow: emit canonical Inspection schema
with full summary skeleton, severity object, cost stub, type_tr — was
crashing frontend with undefined.level_tr / undefined.min_tl.
- config.py s3_public_endpoint: default '' (was localhost:9000 leaking
into prod URLs). Empty falls back to s3_endpoint (B2 host).
- worker.py: detect rediss:// and set broker_use_ssl with ssl_cert_reqs=NONE
(Upstash TLS Redis was 503'ing every async inspect).
- main.py thumbnail_url: filter out local:// URLs from list response.

Frontend:
- api.ts: dynamic timeout for /inspect — sync mode 5min minimum or 60s
per file (was 60s fixed, multi-photo always timed out client-side).
- use-inspection-polling.ts: maxDuration 3min -> 10min (20 foto CPU batch
can take 12min).
- SeverityBadge: guard undefined level (Roboflow path) — was crashing
React tree -> ErrorBoundary -> 'sunucu hatasi' UI.
- CostDisplay: guard undefined total_cost_range_tl (Roboflow path).
- ImageWithOverlay: render placeholder for local:// URLs instead of
silently broken <img>.

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

apps/web/lib/api.ts

@@ -347,11 +347,18 @@ export const inspections = {
     // it automatically so that the multipart boundary token is included in
     // the header. Setting `Content-Type: multipart/form-data` here strips the
     // boundary and the backend rejects the upload as malformed.
+    // CPU-only HF Spaces: tek inference 9-36s; N foto * 45s + upload süresi
+    // global 60s timeout'u aşar → "Bağlantı zaman aşımı" yanlış göstergesi.
+    // Per-call uzatma: en az 5dk, foto başına 60s. Sync mode'da kritik.
+    const dynamicTimeout = mode === 'sync'
+      ? Math.max(300_000, files.length * 60_000)
+      : 120_000;
     const res = await client().post<
       InspectionCreateResponse | SyncInspectionResponse
     >(path, form, {
       headers: apiKey ? { 'X-API-Key': apiKey } : undefined,
       signal,
+      timeout: dynamicTimeout,
       onUploadProgress: (evt) => {
         if (onUploadProgress && evt.total) {
           onUploadProgress(evt.loaded, evt.total);

apps/web/lib/use-inspection-polling.ts

@@ -25,7 +25,8 @@ export interface UseInspectionPollingOptions {
   intervalMs?: number;
   /**
    * Max polling duration in ms before giving up.
-   * Default 180_000 (3 min) — large enough for 20-image async batches.
+   * Default 600_000 (10 min) — CPU inference can be 9-36s/foto; 20 foto
+   * batch = up to 12 dakika. 3dk default kullanıcıyı erken "timeout" yapıyordu.
    */
   maxDurationMs?: number;
   /** Max single interval after exponential backoff. Default 8000. */
@@ -57,7 +58,7 @@ export function useInspectionPolling(
 ): PollingReturn {
   const {
     intervalMs = 1_500,
-    maxDurationMs = 180_000,
+    maxDurationMs = 600_000,
     maxIntervalMs = 8_000,
     enabled = true,
   } = opts;

packages/ui/src/components/CostDisplay.tsx

@@ -22,8 +22,13 @@ const CONF_COLOR: Record<'high' | 'medium' | 'low', string> = {
 };
 
 export function CostDisplay({ summary, className }: Props) {
-  const [min, max] = summary.total_cost_range_tl;
-  const mid = summary.total_cost_midpoint_tl ?? (min + max) / 2;
+  // Guard: Roboflow / pretrained path total_cost_range_tl döndürmeyebilir;
+  // undefined destructure crash önlenir.
+  const range = Array.isArray(summary?.total_cost_range_tl)
+    ? summary.total_cost_range_tl
+    : [0, 0];
+  const [min, max] = [Number(range[0]) || 0, Number(range[1]) || 0];
+  const mid = summary?.total_cost_midpoint_tl ?? (min + max) / 2;
 
   return (
     <div

packages/ui/src/components/ImageWithOverlay.tsx

@@ -177,18 +177,26 @@ export function ImageWithOverlay({
       )}
       style={{ aspectRatio }}
     >
-      <img
-        src={imageUrl}
-        alt={alt}
-        draggable={false}
-        loading="lazy"
-        decoding="async"
-        className="block h-full w-full select-none object-contain"
-        onLoad={(e) => {
-          const t = e.currentTarget;
-          setImgDim({ w: t.naturalWidth, h: t.naturalHeight });
-        }}
-      />
+      {/* Guard: backend STORAGE_OPTIONAL'da `local://skipped/...` URL'i
+          dönebilir; browser bunu fetch edemez — placeholder göster. */}
+      {imageUrl && !imageUrl.startsWith('local://') ? (
+        <img
+          src={imageUrl}
+          alt={alt}
+          draggable={false}
+          loading="lazy"
+          decoding="async"
+          className="block h-full w-full select-none object-contain"
+          onLoad={(e) => {
+            const t = e.currentTarget;
+            setImgDim({ w: t.naturalWidth, h: t.naturalHeight });
+          }}
+        />
+      ) : (
+        <div className="flex h-full w-full items-center justify-center bg-slate-100 text-sm text-slate-500">
+          Görsel kaydedilmedi (storage opsiyonel mod)
+        </div>
+      )}
       <canvas
         ref={canvasRef}
         className="pointer-events-none absolute inset-0 h-full w-full"

packages/ui/src/components/SeverityBadge.tsx

@@ -44,6 +44,9 @@ export function SeverityBadge({
   showDot = false,
   showIcon = true,
 }: Props) {
+  // Guard: backend bazı path'lerde severity dönmeyebilir (Roboflow) — null
+  // veya bilinmeyen değer için render yapma (React.createElement crash önlenir).
+  if (!level || !(level in STYLES)) return null;
   const Icon = ICONS[level];
   return (
     <span
@@ -57,7 +60,7 @@ export function SeverityBadge({
       {showDot && (
         <span className={cn('h-1.5 w-1.5 rounded-full', DOT_COLORS[level])} aria-hidden />
       )}
-      {showIcon && (
+      {showIcon && Icon && (
         <Icon
           className={cn(size === 'sm' ? 'h-3 w-3' : 'h-3.5 w-3.5', ICON_COLORS[level])}
           aria-hidden

services/backend/config.py

@@ -101,9 +101,12 @@ class Settings(BaseSettings):
     ml_unload_after_inference: bool = False
 
     # ---- S3 storage ----
-    # Render production: AWS S3 ya da Cloudflare R2. Dev: MinIO.
+    # Production: AWS S3 / R2 / B2. Dev: MinIO.
     s3_endpoint: str = "http://minio:9000"
-    s3_public_endpoint: str = "http://localhost:9000"
+    # NOT: production'da MUTLAKA S3_PUBLIC_ENDPOINT env'i set edilmeli;
+    # default localhost'tu — kullanici-yuzlu image URL'leri prod'da kirildi.
+    # Bos string fallback: storage.get_image_url s3_endpoint'i kullanir.
+    s3_public_endpoint: str = ""
     s3_access_key: str = "minioadmin"
     s3_secret_key: str = "minioadmin"
     s3_bucket: str = "inspections"

services/backend/main.py

@@ -360,8 +360,10 @@ def update_inspection(inspection_id: str, **fields) -> None:
         return
     sets = []
     values: list = []
+    # JSONB sutunlar — psycopg2 dict adapt edemiyor, manuel json-dump.
+    _JSONB_COLS = {"result", "image_urls", "model_versions", "metadata"}
     for k, v in fields.items():
-        if k in ("result", "image_urls"):
+        if k in _JSONB_COLS:
             v = _json.dumps(v) if v is not None else None
         sets.append(f"{k} = %s")
         values.append(v)
@@ -959,34 +961,81 @@ async def _process_sync(files: List[UploadFile], auth: AuthContext,
     results: List[dict] = []
     per_image: List[dict] = []
 
+    failed_indices: List[int] = []
     for i, f in enumerate(files):
-        content, url = await _store_upload(f, inspection_id, i)
+        try:
+            content, url = await _store_upload(f, inspection_id, i)
+        except HTTPException:
+            raise  # 400/413 - validation, kullaniciya net don
+        except Exception as e:  # noqa: BLE001
+            logger.exception("Store upload hatasi index=%d: %s", i, e)
+            per_image.append({
+                "index": i, "url": None, "status": "failed",
+                "error": f"Goruntu yuklenemedi: {e}",
+                "image": {"url": None}, "parts": [], "summary": {},
+                "unassigned_damages": [], "multi_part_damages": [],
+            })
+            failed_indices.append(i)
+            continue
         image_urls.append(url)
-        img = _decode_image(content, i)
+        try:
+            img = _decode_image(content, i)
+        except HTTPException as e:
+            per_image.append({
+                "index": i, "url": url, "status": "failed",
+                "error": str(e.detail),
+                "image": {"url": url}, "parts": [], "summary": {},
+                "unassigned_damages": [], "multi_part_damages": [],
+            })
+            failed_indices.append(i)
+            continue
         # GPU inference event-loop'u bloklamasin -> threadpool
+        # Per-image error containment: tek foto fail tum batch'i ucurmasin.
         try:
-            # ml_pipeline.analyze(image, retries=2, source=...)
             r = await asyncio.to_thread(ml_pipeline.analyze, img, 2, model)
         except RuntimeError as e:
-            # ML pipeline yuklenememis (pipeline.py yok vb)
-            logger.error("ML pipeline runtime hatasi: %s", e)
-            raise HTTPException(status_code=503, detail="ML servisi su an kullanilamiyor")
+            logger.error("ML pipeline runtime hatasi index=%d: %s", i, e)
+            if len(files) == 1:
+                raise HTTPException(status_code=503, detail="ML servisi su an kullanilamiyor")
+            per_image.append({
+                "index": i, "url": url, "status": "failed",
+                "error": f"ML servisi: {e}",
+                "image": {"url": url}, "parts": [], "summary": {},
+                "unassigned_damages": [], "multi_part_damages": [],
+            })
+            failed_indices.append(i)
+            continue
         except Exception as e:  # noqa: BLE001
-            # CUDA OOM, model exception vs — kullaniciya net mesaj
             msg = str(e).lower()
             if "out of memory" in msg or "cuda" in msg:
-                logger.error("GPU OOM rid-unknown: %s", e)
-                raise HTTPException(status_code=503, detail="GPU bellegi yetersiz, daha kucuk goruntu deneyin")
-            logger.exception("ML analyze hatasi: %s", e)
-            raise HTTPException(status_code=500, detail=f"Analiz hatasi: {e}")
+                logger.error("GPU OOM index=%d: %s", i, e)
+                if len(files) == 1:
+                    raise HTTPException(status_code=503, detail="GPU bellegi yetersiz, daha kucuk goruntu deneyin")
+                per_image.append({
+                    "index": i, "url": url, "status": "failed",
+                    "error": "GPU bellegi yetersiz",
+                    "image": {"url": url}, "parts": [], "summary": {},
+                    "unassigned_damages": [], "multi_part_damages": [],
+                })
+                failed_indices.append(i)
+                continue
+            logger.exception("ML analyze hatasi index=%d: %s", i, e)
+            if len(files) == 1:
+                raise HTTPException(status_code=500, detail=f"Analiz hatasi: {e}")
+            per_image.append({
+                "index": i, "url": url, "status": "failed",
+                "error": f"Analiz hatasi: {e}",
+                "image": {"url": url}, "parts": [], "summary": {},
+                "unassigned_damages": [], "multi_part_damages": [],
+            })
+            failed_indices.append(i)
+            continue
         if isinstance(r, dict):
             img_blk = r.get("image") if isinstance(r.get("image"), dict) else {}
-            # Pipeline'in legacy "<inline>" donmesi durumunda override et.
             if (not img_blk.get("url")) or img_blk.get("url") == "<inline>":
                 img_blk["url"] = url
             r["image"] = img_blk
         results.append(r)
-        # Per-image kart kaydi (frontend "N foto = N sonuc" beklentisi).
         per_image.append({
             "index": i,
             "url": url,
@@ -998,7 +1047,20 @@ async def _process_sync(files: List[UploadFile], auth: AuthContext,
             "multi_part_damages": (r.get("multi_part_damages") if isinstance(r, dict) else []) or [],
         })
 
-    aggregated = aggregate_results(results) if len(results) > 1 else dict(results[0])
+    # En az 1 sonuc yoksa toplu fail; sıralamayı sayfanın bozulmaması için
+    # results bos olsa bile per_image listesi UI'a doner.
+    if not results:
+        raise HTTPException(status_code=500, detail=(
+            f"Hicbir goruntu analiz edilemedi ({len(failed_indices)} adet basarisiz)"
+        ))
+
+    try:
+        aggregated = aggregate_results(results) if len(results) > 1 else dict(results[0])
+    except Exception as e:  # noqa: BLE001
+        logger.exception("aggregate_results crash: %s", e)
+        # Fallback: ilk sonucu ham dondur, per_image kullanici icin yeterli
+        aggregated = dict(results[0])
+        aggregated["_aggregation_error"] = str(e)
     # inspection_id'yi zorla yerlestir
     aggregated["inspection_id"] = inspection_id
     aggregated["images"] = per_image
@@ -1267,7 +1329,8 @@ async def list_inspections(
             iu = r.get("image_urls")
             if isinstance(iu, list) and iu:
                 cand = iu[0]
-                if isinstance(cand, str) and cand and cand != "<inline>":
+                if isinstance(cand, str) and cand and cand != "<inline>" \
+                        and not cand.startswith("local://"):
                     thumb = cand
 
         inspection_id_val = r["id"] if "id" in r else r.get("inspection_id")

services/backend/ml_service.py

@@ -25,6 +25,7 @@ import logging
 import sys
 import threading
 import time
+from datetime import datetime, timezone
 from pathlib import Path
 from typing import Any, Optional
 
@@ -340,8 +341,9 @@ class MLPipeline:
         """Pretrained Roboflow scratch_dent v3 modelini HTTP API ile cagir.
 
         Custom pipeline atlatilir; ne damage modeli ne parts ne severity
-        yuklenir. Sadece bbox-detection sonucu doner. Frontend bunu
-        "Roboflow ile basit hasar tespiti" olarak gosterir.
+        yuklenir. Frontend Inspection schema uyumlu bir cikti uretir:
+        Roboflow detection'lari `unassigned_damages` listesine konur
+        (parts boş kalir, schema match olur).
         """
         import cv2  # local import
         from roboflow_inference import (  # type: ignore
@@ -361,30 +363,106 @@ class MLPipeline:
             raise RuntimeError("Goruntu JPEG encode edilemedi")
         img_bytes = buf.tobytes()
 
-        damages = run_roboflow_damage_inference(
+        raw_damages = run_roboflow_damage_inference(
             img_bytes,
             workspace="carpro",
             project="car-scratch-and-dent",
             version=3,
         )
 
+        # TR ceviri + frontend Damage schema'sina map et
+        TR = {"dent": "Göçük", "scratch": "Çizik", "damage": "Hasar"}
+        SEVERITY_TR = {"hafif": "Hafif", "orta": "Orta", "agir": "Ağır"}
+
+        unassigned: list[dict[str, Any]] = []
+        for d in raw_damages:
+            x1, y1, x2, y2 = d.get("bbox", [0, 0, 0, 0])
+            bbox_w = max(0.0, x2 - x1)
+            bbox_h = max(0.0, y2 - y1)
+            area_ratio = (bbox_w * bbox_h) / max(1.0, float(w) * float(h))
+            # Basit kural-tabanli severity (confidence + alan)
+            conf = float(d.get("confidence", 0.0))
+            if area_ratio > 0.15 or conf > 0.85:
+                sev_level, sev_conf = "orta", 0.5
+            elif area_ratio > 0.05 or conf > 0.7:
+                sev_level, sev_conf = "hafif", 0.5
+            else:
+                sev_level, sev_conf = "hafif", 0.4
+
+            dtype = d.get("class") or "damage"
+            unassigned.append({
+                "id": d.get("id", 0),
+                "type": dtype,
+                "type_tr": TR.get(dtype, dtype.title()),
+                "confidence": conf,
+                "bbox": d.get("bbox", [0, 0, 0, 0]),
+                "polygon": d.get("polygon", []) or [],
+                "polygon_normalized": [],  # detection-only model
+                "area_ratio": area_ratio,
+                "severity": {
+                    "level": sev_level,
+                    "level_tr": SEVERITY_TR.get(sev_level, sev_level.title()),
+                    "confidence": sev_conf,
+                    "method": "rule_based_roboflow",
+                },
+                "cost": {
+                    "min_tl": 0,
+                    "max_tl": 0,
+                    "confidence": "low",
+                    "source": "roboflow_no_cost",
+                },
+                "is_multi_part": False,
+                "is_low_confidence_match": False,
+                "source": "roboflow",
+            })
+
+        total_damage = len(unassigned)
+        most_severe = None
+        most_severe_tr = None
+        if unassigned:
+            # En agir level'i bul
+            order = {"hafif": 1, "orta": 2, "agir": 3}
+            top = max(unassigned, key=lambda u: order.get(u["severity"]["level"], 0))
+            most_severe = top["severity"]["level"]
+            most_severe_tr = top["severity"]["level_tr"]
+
         return {
-            "image_size": {"width": int(w), "height": int(h)},
+            "timestamp": datetime.now(timezone.utc).isoformat(),
+            "image": {"url": None, "width": int(w), "height": int(h)},
             "parts": [],
-            "damages": damages,
+            "unassigned_damages": unassigned,
+            "multi_part_damages": [],
             "summary": {
-                "total_damage_count": len(damages),
-                "estimated_repair_days": 0,
+                "total_parts_inspected": 0,
+                "damaged_parts_count": 0,
+                "clean_parts_count": 0,
+                "total_damage_count": total_damage,
+                "unknown_part_damages_count": total_damage,
+                "multi_part_damages_count": 0,
+                "most_severe_level": most_severe,
+                "most_severe_level_tr": most_severe_tr,
+                "total_damage_area_ratio": sum(u["area_ratio"] for u in unassigned),
+                "total_cost_range_tl": [0, 0],
+                "total_cost_midpoint_tl": 0,
+                "cost_confidence": "low",
+                "repair_recommendation": "manual_review" if unassigned else "hasar_yok",
+                "repair_recommendation_tr": (
+                    "Manuel inceleme önerilir (Roboflow: maliyet yok)"
+                    if unassigned else "Hasar tespit edilmedi"
+                ),
+                "estimated_repair_days": 1 if unassigned else 0,
                 "model_source": "roboflow",
                 "note": (
                     "Roboflow scratch_dent v3 hosted inference. "
-                    "Parca segmentasyonu ve siddet siniflandirmasi yok; "
-                    "sadece basit hasar bbox tespiti."
+                    "Parça segmentasyonu / maliyet hesaplaması yapılmaz."
                 ),
             },
+            "visualization_urls": {"annotated": None, "parts": None, "damages": None},
             "model_versions": {
                 "pretrained_source": "roboflow_cardd_scratch_dent_v3",
+                "requested_model": "pretrained_roboflow_cardd",
             },
+            "model_source": "roboflow",
         }
 
 
@@ -533,29 +611,37 @@ def check_model_files_available(model_id: Optional[str]) -> tuple[bool, str]:
     if not model_id or model_id == DEFAULT_MODEL_ID:
         return True, ""
     try:
-        from pretrained_registry import REGISTRY  # type: ignore
-        entry = REGISTRY.get(model_id) if isinstance(REGISTRY, dict) else None
-        if entry is None:
-            for m in list_available_models():
-                if m.get("id") == model_id:
-                    if m.get("available") is False:
-                        return False, (
-                            f"'{m.get('name', model_id)}' modeli bu deploy'da "
-                            "indirilmemis. Lutfen 'Kendi Modellerim' (custom) "
-                            "secenegini kullanin."
-                        )
-                    return True, ""
-            return False, f"Model bulunamadi: {model_id}"
-        if hasattr(entry, "is_available") and not entry.is_available():
-            return False, (
-                f"'{getattr(entry, 'name', model_id)}' modeli bu deploy'da "
-                "indirilmemis. Lutfen 'Kendi Modellerim' (custom) "
-                "secenegini kullanin."
-            )
-        return True, ""
+        # Registry'den entry'i al — modul `get_registry()` veya direkt erisim
+        # destekliyor. REGISTRY sembolu yok; eski kodda hata kaynagiydi.
+        from pretrained_registry import get_registry  # type: ignore
+        reg = get_registry()
+        entry = None
+        # PretrainedRegistry sinifinda get() metodu var
+        if hasattr(reg, "get"):
+            entry = reg.get(model_id)
+        # Eger entry uygunsa dosya/key check
+        if entry is not None and hasattr(entry, "is_available"):
+            if not entry.is_available():
+                return False, (
+                    f"'{getattr(entry, 'name', model_id)}' modeli bu deploy'da "
+                    "indirilmemis. Lutfen 'Kendi Modellerim' (custom) "
+                    "secenegini kullanin."
+                )
+            return True, ""
+        # Source-level model_id ise (pretrained_roboflow_cardd vs)
+        for m in list_available_models():
+            if m.get("id") == model_id:
+                if m.get("available") is False:
+                    return False, (
+                        f"'{m.get('name', model_id)}' modeli bu deploy'da "
+                        "indirilmemis. Lutfen 'Kendi Modellerim' (custom) "
+                        "secenegini kullanin."
+                    )
+                return True, ""
+        return False, f"Model bulunamadi: {model_id}"
     except Exception as exc:  # noqa: BLE001
         logger.warning("check_model_files_available hata: %s", exc)
-        return True, ""
+        return True, ""  # fail-open; gerçek inference patlarsa orada handle
 
 
 def resolve_model_id(model_id: Optional[str]) -> str:

services/backend/worker.py

@@ -36,10 +36,17 @@ logger = logging.getLogger(__name__)
 
 # ============================ Celery app ============================
 
+_broker_url = settings.redis_url
+# Upstash/managed Redis genelde rediss:// (TLS) — kombu default insecure
+# warning veriyor + 'ssl_cert_reqs' eksik error firlatiyor. Explicit set.
+import ssl as _ssl
+_uses_tls = _broker_url.startswith("rediss://")
+_ssl_opts = {"ssl_cert_reqs": _ssl.CERT_NONE} if _uses_tls else None
+
 celery_app = Celery(
     "arac_hasar",
-    broker=settings.redis_url,
-    backend=settings.redis_url,
+    broker=_broker_url,
+    backend=_broker_url,
 )
 
 celery_app.conf.update(
@@ -48,15 +55,17 @@ celery_app.conf.update(
     result_serializer="json",
     timezone="Europe/Istanbul",
     enable_utc=True,
-    # Limitler — uzun pipeline'lara karsi guvenli
     task_soft_time_limit=180,
     task_time_limit=240,
     task_acks_late=True,
     task_reject_on_worker_lost=True,
-    worker_prefetch_multiplier=1,  # GPU bound: bir seferde 1 task al
-    worker_max_tasks_per_child=50,  # Memory leak korumasi
+    worker_prefetch_multiplier=1,
+    worker_max_tasks_per_child=50,
     broker_connection_retry_on_startup=True,
 )
+if _ssl_opts:
+    celery_app.conf.broker_use_ssl = _ssl_opts
+    celery_app.conf.redis_backend_use_ssl = _ssl_opts
 
 
 # ============================ Pub-sub helper ============================