Refactor email content generation and update email sending logic

- Simplified OTP and password reset email content generation by removing HTML rendering and returning plain text only.
- Updated the `_send_email` function to send only plain text emails.
- Adjusted the registration, login, and password reset flows to use the new email content functions.
- Added a new `report_payload` column to the `ScreeningReport` model for storing additional report data.
- Introduced Celery tasks for asynchronous DICOM processing and batch handling, including progress tracking via Redis.
- Enhanced error handling in user loading and added logging for SQLAlchemy errors.
- Updated various templates to reflect the new branding as "AI Medical Intelligence Pipeline" and improved UI elements.
- Added ground truth update functionality in the detail view.
- Implemented LLM information display in the report detail view.

Co-authored-by: Copilot <copilot@github.com>

.env.example

@@ -57,6 +57,15 @@ ICH_PUBLIC_BASE_URL=
 # Optional local debugging for auth emails (prints OTP/reset link to server logs)
 ICH_DEBUG_AUTH_EMAILS=false
 
+# ════════════════════════════════════════════════════════════════════════════
+# CELERY + REDIS (ASYNC TASK QUEUE FOR BATCH PROCESSING)
+# ════════════════════════════════════════════════════════════════════════════
+# Redis broker and result backend for Celery workers.
+# Local dev: redis://localhost:6379/0
+# Upstash (cloud): rediss://default:<auth_token>@<hostname>:<port>
+# Leave empty to use default local Redis
+REDIS_URL=
+
 # ════════════════════════════════════════════════════════════════════════════
 # LOGGING & MONITORING
 # ════════════════════════════════════════════════════════════════════════════

README.md

@@ -1,6 +1,6 @@
-# Intracranial Hemorrhage Detection
+# AI Medical Intelligence Pipeline for CT Scan Analysis
 
-AI-assisted screening system for intracranial hemorrhage (ICH) from head CT (DICOM) images.
+AI medical intelligence pipeline for intracranial hemorrhage (ICH) analysis from head CT (DICOM) images.
 
 This project provides a Flask web interface for:
 
@@ -12,7 +12,7 @@ This project provides a Flask web interface for:
 
 ## Project Overview
 
-Intracranial hemorrhage is a time-critical emergency finding in neuroimaging. This repository focuses on a practical screening workflow with explainability and structured report output.
+Intracranial hemorrhage is a time-critical emergency finding in neuroimaging. This repository focuses on a practical intelligence pipeline with explainability and structured report output.
 
 The system is built for decision support and triage assistance, not standalone diagnosis.
 

app_new.py

@@ -25,12 +25,12 @@ import os
 import shutil
 import sys
 import tempfile
-import threading
 import time
 import uuid
 import zipfile
 import math
 from dataclasses import dataclass
+from getpass import getpass
 from pathlib import Path
 from typing import Any
 
@@ -66,9 +66,12 @@ except Exception:
     bbr = _NoopRecorder()
 
 from flask import (
-    Flask, abort, flash, g, jsonify, redirect, render_template, request,
+    Flask, Response, abort, flash, g, jsonify, redirect, render_template, request,
     send_from_directory, url_for
 )
+from types import SimpleNamespace
+from celery.result import AsyncResult
+from tasks import REDIS_URL, celery_app
 from werkzeug.utils import secure_filename
 from werkzeug.middleware.proxy_fix import ProxyFix
 from flask_login import current_user, login_required
@@ -121,6 +124,7 @@ DATABASE_URL = os.environ.get("DATABASE_URL", "").strip()
 HF_MODEL_REPO = os.environ.get("ICH_HF_MODEL_REPO", "").strip()
 HF_TOKEN = os.environ.get("ICH_HF_TOKEN", "").strip()
 LOCAL_MODE = _env_bool("ICH_LOCAL_MODE", True)
+SHOW_LOGS = _env_bool("ICH_SHOW_LOGS", False)
 
 # ══════════════════════════════════════════════════════════════════════════
 #  FLASK APP SETUP
@@ -135,6 +139,10 @@ app.config.update(
     SECRET_KEY=SECRET_KEY or os.urandom(32).hex(),
     DEBUG=APP_DEBUG and os.environ.get("FLASK_ENV") == "development",
     SQLALCHEMY_DATABASE_URI=DATABASE_URL or "sqlite:///ich_app.db",
+    SQLALCHEMY_ENGINE_OPTIONS={
+        "pool_pre_ping": True,
+        "pool_recycle": 280,
+    },
     SQLALCHEMY_TRACK_MODIFICATIONS=False,
     SESSION_COOKIE_SECURE=not APP_DEBUG,
     SESSION_COOKIE_HTTPONLY=True,
@@ -150,6 +158,16 @@ init_security(app)
 # Register blueprints
 app.register_blueprint(auth_bp)
 
+@app.context_processor
+def inject_feature_flags():
+    log_count = 0
+    if SHOW_LOGS and LOGS_DIR.exists():
+        try:
+            log_count = sum(1 for path in LOGS_DIR.iterdir() if path.suffix == ".json")
+        except OSError:
+            log_count = 0
+    return {"show_logs": SHOW_LOGS, "log_count": log_count}
+
 # ══════════════════════════════════════════════════════════════════════════
 #  LOGGING
 # ══════════════════════════════════════════════════════════════════════════
@@ -194,9 +212,6 @@ _MODEL: dict[str, Any] = {
     "inference_mod": None,
 }
 
-_BATCHES: dict[str, dict[str, Any]] = {}
-_BATCHES_LOCK = threading.Lock()
-
 # ══════════════════════════════════════════════════════════════════════════
 #  MODEL LOADING
 # ══════════════════════════════════════════════════════════════════════════
@@ -305,14 +320,18 @@ def _ensure_model_loaded() -> bool:
 #  INFERENCE & BATCH PROCESSING
 # ══════════════════════════════════════════════════════════════════════════
 
-def _run_inference_on_dcm(dcm_path: Path, user_id: int) -> tuple[dict[str, Any] | None, dict[str, Any] | None]:
+def _run_inference_on_dcm(
+    dcm_path: Path,
+    user_id: int,
+    upload_id: int,
+) -> tuple[dict[str, Any] | None, dict[str, Any] | None]:
     """Run inference on a single DICOM file"""
     if not _ensure_model_loaded():
         return None, None
     
     ri_mod = _MODEL["inference_mod"]
     image_id = dcm_path.stem
-    user_reports_dir = UserDataManager(UPLOAD_BASE_DIR).get_user_reports_dir(user_id)
+    user_reports_dir = UserDataManager().get_user_reports_dir(user_id)
     
     bbr.start()
     
@@ -338,26 +357,24 @@ def _run_inference_on_dcm(dcm_path: Path, user_id: int) -> tuple[dict[str, Any]
         pred.setdefault("calibrated_probability", inference.get("cal_prob_any"))
         pred.setdefault("decision_threshold", pred.get("decision_threshold_any"))
         report["prediction"] = pred
+
+        explainability = report.get("explainability", {}) if isinstance(report, dict) else {}
+        gradcam_reference = (
+            report.get("cloudinary_heatmap_url")
+            or explainability.get("heatmap_path")
+            or explainability.get("image_path")
+        )
         
         report_path = user_reports_dir / f"{image_id}_report.json"
         with open(report_path, "w") as f:
             json.dump(report, f, indent=2)
         
-        upload = ScreeningUpload(
-            user_id=user_id,
-            file_name=dcm_path.name,
-            original_filename=dcm_path.name,
-            file_size=dcm_path.stat().st_size if dcm_path.exists() else 0,
-            file_path=str(dcm_path.relative_to(BASE_DIR)) if dcm_path.is_relative_to(BASE_DIR) else str(dcm_path),
-            processing_status='completed'
-        )
-        db.session.add(upload)
-        db.session.flush()
-
         # Save to database
+        user_data_dir = UserDataManager().get_user_data_dir(user_id)
+
         screening_report = ScreeningReport(
             user_id=user_id,
-            upload_id=upload.id,
+            upload_id=upload_id,
             image_id=image_id,
             screening_outcome=pred.get("screening_outcome"),
             raw_probability=pred.get("raw_probability"),
@@ -366,9 +383,10 @@ def _run_inference_on_dcm(dcm_path: Path, user_id: int) -> tuple[dict[str, Any]
             decision_threshold=pred.get("decision_threshold"),
             triage_action=report.get("triage", {}).get("action"),
             urgency=report.get("triage", {}).get("urgency"),
+            report_json_path=str(report_path.relative_to(user_data_dir)),
+            gradcam_image_path=gradcam_reference,
             llm_summary=report.get("llm_summary"),
-            report_json_path=str(report_path.relative_to(BASE_DIR)),
-            gradcam_image_path=report.get("cloudinary_heatmap_url") or str((user_reports_dir / f"{image_id}_gradcam.png").relative_to(BASE_DIR)),
+            report_payload=json.dumps(report, ensure_ascii=True),
             generated_at=datetime.datetime.utcnow(),
         )
         db.session.add(screening_report)
@@ -378,6 +396,7 @@ def _run_inference_on_dcm(dcm_path: Path, user_id: int) -> tuple[dict[str, Any]
                  resource_id=screening_report.id, status="success")
     
     except Exception as e:
+        db.session.rollback()
         bbr.stop()
         logger.error(f"Inference failed: {e}", exc_info=True)
         log_audit("inference_failed", user_id=user_id, status="failure", details=str(e))
@@ -396,87 +415,139 @@ def _run_inference_on_dcm(dcm_path: Path, user_id: int) -> tuple[dict[str, Any]
     
     return report, {"timestamp": ts, "image_id": image_id}
 
-def _new_batch(user_id: int, total: int, temp_dir: str | None = None) -> str:
-    """Create a batch processing job"""
-    batch_id = uuid.uuid4().hex[:12]
-    with _BATCHES_LOCK:
-        _BATCHES[batch_id] = {
-            "user_id": user_id,
-            "status": "running",
-            "total": total,
-            "processed": 0,
-            "succeeded": 0,
-            "failed_ids": [],
-            "current_file": "",
-            "image_ids": [],
-            "started_at": datetime.datetime.now().isoformat(),
-            "finished_at": None,
-            "error": None,
-            "temp_dir": temp_dir,
-        }
+def _start_batch(dcm_paths: list[Path], user_id: int, temp_dir: str | None = None) -> str:
+    """Trigger async batch processing via Celery."""
+    batch_id = f"u{user_id}_{uuid.uuid4().hex[:12]}"
+    dcm_paths_str = [str(p) for p in dcm_paths]
+    
+    # Send task to Celery worker
+    try:
+        task = celery_app.send_task(
+            "tasks.process_dicom_batch",
+            kwargs={
+                "batch_id": batch_id,
+                "dcm_paths": dcm_paths_str,
+                "user_id": user_id,
+                "temp_dir": temp_dir,
+            },
+            task_id=batch_id,
+        )
+    except Exception as exc:
+        logger.error("Failed to enqueue Celery batch task", exc_info=True)
+        raise RuntimeError("Celery enqueue failed") from exc
+    
+    logger.info(f"Started Celery batch task {batch_id} (task_id={task.id})")
     return batch_id
 
-def _batch_update(batch_id: str, **kw: Any) -> None:
-    """Update batch job status"""
-    with _BATCHES_LOCK:
-        if batch_id in _BATCHES:
-            _BATCHES[batch_id].update(kw)
 
-def _run_batch_worker(batch_id: str, dcm_paths: list[Path], user_id: int):
-    """Process multiple DICOM files in background"""
-    with app.app_context():
-        succeeded_ids = []
-        failed_ids = []
-        
-        for i, path in enumerate(dcm_paths, 1):
+def _run_batch_sync(dcm_paths: list[Path], user_id: int, temp_dir: str | None = None) -> dict[str, Any]:
+    """Fallback synchronous batch processing when Celery is unavailable."""
+    total = len(dcm_paths)
+    succeeded_ids: list[str] = []
+    failed_ids: list[str] = []
+    started_at = datetime.datetime.now().isoformat()
+    sync_batch_id = f"sync_u{user_id}_{uuid.uuid4().hex[:12]}"
+
+    log_audit(
+        "batch_sync_started",
+        user_id=user_id,
+        details=f"batch_id={sync_batch_id}, files={total}",
+        status="success",
+    )
+
+    user_upload_dir = UserDataManager().get_user_upload_dir(user_id)
+
+    try:
+        for path in dcm_paths:
             image_id = path.stem
-            _batch_update(batch_id, current_file=image_id, processed=i - 1)
-            
+
+            upload_record = ScreeningUpload(
+                user_id=user_id,
+                file_name=path.name,
+                original_filename=path.name,
+                file_size=path.stat().st_size if path.exists() else None,
+                file_path=str(path.relative_to(user_upload_dir)) if path.parent == user_upload_dir else str(path),
+                processing_status="processing",
+            )
+            db.session.add(upload_record)
+            db.session.commit()
+
             try:
-                report, _ = _run_inference_on_dcm(path, user_id)
+                report, _ = _run_inference_on_dcm(path, user_id, upload_record.id)
                 if report:
+                    upload_record.processing_status = "completed"
+                    db.session.commit()
                     succeeded_ids.append(image_id)
                 else:
+                    upload_record.processing_status = "failed"
+                    db.session.commit()
                     failed_ids.append(image_id)
-            except Exception as e:
-                logger.error(f"Batch {batch_id}: failed {image_id} — {e}")
+            except Exception as exc:
+                logger.error(f"Sync batch failed {image_id} — {exc}", exc_info=True)
+                db.session.rollback()
+                upload_record.processing_status = "failed"
+                try:
+                    db.session.commit()
+                except Exception:
+                    db.session.rollback()
                 failed_ids.append(image_id)
-            
-            _batch_update(
-                batch_id,
-                processed=i,
-                succeeded=len(succeeded_ids),
-                image_ids=list(succeeded_ids),
-                failed_ids=list(failed_ids),
-            )
-        
-        # Clean up
-        with _BATCHES_LOCK:
-            b = _BATCHES.get(batch_id, {})
-            td = b.get("temp_dir")
-        if td and Path(td).exists():
-            shutil.rmtree(td, ignore_errors=True)
-        
-        _batch_update(
-            batch_id,
-            status="completed",
-            current_file="",
-            finished_at=datetime.datetime.now().isoformat(),
-        )
-        logger.info(f"Batch {batch_id} complete: {len(succeeded_ids)}/{len(dcm_paths)}, {len(failed_ids)} failed")
-
-def _start_batch(dcm_paths: list[Path], user_id: int, temp_dir: str | None = None) -> str:
-    """Start async batch processing"""
-    batch_id = _new_batch(user_id, len(dcm_paths), temp_dir)
-    t = threading.Thread(
-        target=_run_batch_worker,
-        args=(batch_id, dcm_paths, user_id),
-        daemon=True,
-        name=f"batch-{batch_id}",
+    finally:
+        if temp_dir and Path(temp_dir).exists():
+            try:
+                shutil.rmtree(temp_dir, ignore_errors=True)
+                logger.info(f"Cleaned up temp_dir: {temp_dir}")
+            except Exception as exc:
+                logger.warning(f"Failed to clean temp_dir {temp_dir}: {exc}")
+
+    log_audit(
+        "batch_sync_completed",
+        user_id=user_id,
+        details=(
+            f"batch_id={sync_batch_id}, processed={total}, "
+            f"succeeded={len(succeeded_ids)}, failed={len(failed_ids)}"
+        ),
+        status="success" if not failed_ids else "partial",
     )
-    t.start()
-    return batch_id
 
+    return {
+        "batch_id": sync_batch_id,
+        "user_id": user_id,
+        "status": "completed",
+        "total": total,
+        "processed": total,
+        "succeeded": len(succeeded_ids),
+        "failed_ids": list(failed_ids),
+        "image_ids": list(succeeded_ids),
+        "current_file": "",
+        "started_at": started_at,
+        "finished_at": datetime.datetime.now().isoformat(),
+        "error": None,
+        "temp_dir": temp_dir,
+    }
+
+
+def _extract_user_id_from_batch_id(batch_id: str) -> int | None:
+    """Recover the user id embedded in a batch id."""
+    if not batch_id.startswith("u"):
+        return None
+    user_part = batch_id.split("_", 1)[0][1:]
+    try:
+        return int(user_part)
+    except ValueError:
+        return None
+
+
+def _get_queue_depth() -> int | None:
+    """Best-effort queue depth for the default Celery queue."""
+    if not REDIS_URL.startswith("redis"):
+        return None
+
+    try:
+        from redis import Redis
+        client = Redis.from_url(REDIS_URL, decode_responses=True)
+        return int(client.llen("celery"))
+    except Exception:
+        return None
 # ══════════════════════════════════════════════════════════════════════════
 #  DATA MODEL & UTILITIES
 # ══════════════════════════════════════════════════════════════════════════
@@ -493,7 +564,15 @@ class CaseRow:
     urgency: str = "N/A"
     generated_at: str = ""
     report_file: str | None = None
-    gradcam_url: str | None = None
+    gradcam_file: str | None = None
+
+    @property
+    def gradcam_url(self) -> str | None:
+        if not self.gradcam_file:
+            return None
+        if self.gradcam_file.startswith("http"):
+            return self.gradcam_file
+        return self.gradcam_file
     
     @property
     def date_display(self) -> str:
@@ -517,13 +596,6 @@ def _load_user_cases(user_id: int) -> list[CaseRow]:
     
     cases = []
     for r in reports:
-        # Fallback for old records with missing gradcam_image_path
-        g_url = r.gradcam_image_path
-        if not g_url:
-            fallback_path = UserDataManager(UPLOAD_BASE_DIR).get_user_reports_dir(current_user.id) / f"{r.image_id}_gradcam.png"
-            if fallback_path.exists():
-                g_url = url_for('serve_gradcam', filename=fallback_path.name)
-
         cases.append(CaseRow(
             image_id=r.image_id,
             outcome=r.screening_outcome or "Unknown",
@@ -534,11 +606,50 @@ def _load_user_cases(user_id: int) -> list[CaseRow]:
             urgency=r.urgency or "N/A",
             generated_at=r.generated_at.isoformat() if r.generated_at else "",
             report_file=Path(r.report_json_path).name if r.report_json_path else None,
-            gradcam_url=g_url,
+            gradcam_file=_resolve_gradcam_reference(r),
         ))
     
     return cases
 
+
+def _resolve_gradcam_reference(report: ScreeningReport) -> str | None:
+    """Resolve the best available Grad-CAM reference for a report."""
+    if report.gradcam_image_path:
+        return str(report.gradcam_image_path)
+
+    if report.report_payload:
+        try:
+            payload = json.loads(report.report_payload)
+            explainability = payload.get("explainability", {}) if isinstance(payload, dict) else {}
+            return (
+                payload.get("cloudinary_heatmap_url")
+                or explainability.get("heatmap_path")
+                or explainability.get("image_path")
+            )
+        except json.JSONDecodeError:
+            pass
+
+    if not report.report_json_path:
+        return None
+
+    try:
+        user_data_dir = UserDataManager().get_user_data_dir(report.user_id)
+        report_path = user_data_dir / report.report_json_path
+        if not report_path.exists():
+            return None
+
+        with open(report_path, "r", encoding="utf-8") as f:
+            payload = json.load(f)
+
+        explainability = payload.get("explainability", {}) if isinstance(payload, dict) else {}
+        return (
+            payload.get("cloudinary_heatmap_url")
+            or explainability.get("heatmap_path")
+            or explainability.get("image_path")
+        )
+    except (OSError, json.JSONDecodeError, TypeError, AttributeError):
+        return None
+
 def compute_stats(rows: list[CaseRow]) -> dict[str, Any]:
     """Compute statistics for dashboard"""
     total = len(rows)
@@ -555,7 +666,53 @@ def compute_stats(rows: list[CaseRow]) -> dict[str, Any]:
         "urgent": urgent,
         "avg_cal_prob": avg_cal,
         "pos_rate": pos_rate,
-        "heatmaps": sum(1 for r in rows if r.gradcam_url),
+        "heatmaps": sum(1 for r in rows if r.gradcam_file),
+    }
+
+
+def _compute_ground_truth_stats(user_id: int) -> dict[str, Any]:
+    """Compute ground-truth agreement stats for a user."""
+    reports = ScreeningReport.query.filter_by(user_id=user_id).all()
+    labeled = [r for r in reports if (r.true_label or "").upper() in ("POSITIVE", "NEGATIVE")]
+    total = len(labeled)
+    if total == 0:
+        return {
+            "total": 0,
+            "tp": 0,
+            "tn": 0,
+            "fp": 0,
+            "fn": 0,
+            "accuracy": None,
+            "fp_rate": None,
+        }
+
+    def _ai_positive(report: ScreeningReport) -> bool:
+        return "no hemorrhage" not in (report.screening_outcome or "").lower()
+
+    tp = tn = fp = fn = 0
+    for r in labeled:
+        ai_pos = _ai_positive(r)
+        truth_pos = (r.true_label or "").upper() == "POSITIVE"
+        if ai_pos and truth_pos:
+            tp += 1
+        elif ai_pos and not truth_pos:
+            fp += 1
+        elif not ai_pos and truth_pos:
+            fn += 1
+        else:
+            tn += 1
+
+    accuracy = (tp + tn) / total if total else None
+    fp_rate = fp / (fp + tn) if (fp + tn) else None
+
+    return {
+        "total": total,
+        "tp": tp,
+        "tn": tn,
+        "fp": fp,
+        "fn": fn,
+        "accuracy": accuracy,
+        "fp_rate": fp_rate,
     }
 
 
@@ -658,7 +815,7 @@ def analyze():
         flash("No files were uploaded.", "error")
         return redirect(url_for("upload"))
     
-    user_upload_dir = UserDataManager(UPLOAD_BASE_DIR).get_user_upload_dir(current_user.id)
+    user_upload_dir = UserDataManager().get_user_upload_dir(current_user.id)
     user_upload_dir.mkdir(parents=True, exist_ok=True)
     
     dcm_paths: list[Path] = []
@@ -700,12 +857,28 @@ def analyze():
     if len(dcm_paths) == 1 and temp_dir is None:
         path = dcm_paths[0]
         try:
-            report, _ = _run_inference_on_dcm(path, current_user.id)
+            user_upload_dir = UserDataManager().get_user_upload_dir(current_user.id)
+            upload_record = ScreeningUpload(
+                user_id=current_user.id,
+                file_name=path.name,
+                original_filename=path.name,
+                file_size=path.stat().st_size if path.exists() else None,
+                file_path=str(path.relative_to(user_upload_dir)) if path.parent == user_upload_dir else str(path),
+                processing_status="processing",
+            )
+            db.session.add(upload_record)
+            db.session.commit()
+
+            report, _ = _run_inference_on_dcm(path, current_user.id, upload_record.id)
             if not report:
                 flash("Model failed to load. Check server logs.", "error")
                 return redirect(url_for("upload"))
+
+            upload_record.processing_status = "completed"
+            db.session.commit()
             return redirect(url_for("case_detail", image_id=path.stem))
         except Exception as e:
+            db.session.rollback()
             logger.error(f"Analysis failed: {e}")
             log_audit("analysis_failed", user_id=current_user.id, status="failure", details=str(e))
             flash(f"Analysis failed: {e}", "error")
@@ -715,10 +888,23 @@ def analyze():
                 path.unlink()
     
     # Multiple files - async batch
-    batch_id = _start_batch(dcm_paths, current_user.id, temp_dir)
-    log_audit("batch_started", user_id=current_user.id, 
-             details=f"batch_id={batch_id}, files={len(dcm_paths)}")
-    return redirect(url_for("batch_progress", batch_id=batch_id))
+    try:
+        batch_id = _start_batch(dcm_paths, current_user.id, temp_dir)
+        log_audit(
+            "batch_started",
+            user_id=current_user.id,
+            details=f"batch_id={batch_id}, files={len(dcm_paths)}",
+        )
+        return redirect(url_for("batch_progress", batch_id=batch_id))
+    except Exception:
+        logger.error("Celery unavailable; running synchronous fallback", exc_info=True)
+        flash("Celery worker unavailable. Running batch synchronously; this may take a while.", "warning")
+        result = _run_batch_sync(dcm_paths, current_user.id, temp_dir)
+        flash(
+            f"Batch complete: {result['succeeded']}/{result['total']} succeeded.",
+            "info",
+        )
+        return redirect(url_for("reports"))
 
 
 @app.route("/analyze/directory", methods=["POST"])
@@ -728,22 +914,14 @@ def analyze_directory():
     if not LOCAL_MODE:
         abort(403)
 
-    dir_path_str = request.form.get("dir_path", "").strip().strip("'\"")
+    dir_path_str = request.form.get("dir_path", "").strip()
     if not dir_path_str:
         flash("Please enter a directory path.", "error")
         return redirect(url_for("upload"))
 
-    if len(dir_path_str) > 4096:
-        flash("Path is too long to be a valid directory.", "error")
-        return redirect(url_for("upload"))
-
-    scan_dir = Path(dir_path_str).expanduser().resolve()
-    try:
-        if not scan_dir.is_dir():
-            flash(f"Directory not found: {dir_path_str}", "error")
-            return redirect(url_for("upload"))
-    except OSError:
-        flash("Invalid directory path format.", "error")
+    scan_dir = Path(dir_path_str)
+    if not scan_dir.is_dir():
+        flash(f"Directory not found: {dir_path_str}", "error")
         return redirect(url_for("upload"))
 
     dcm_paths = sorted(scan_dir.rglob("*.dcm"))
@@ -751,32 +929,125 @@ def analyze_directory():
         flash(f"No .dcm files found in: {dir_path_str}", "error")
         return redirect(url_for("upload"))
 
-    batch_id = _start_batch(dcm_paths, current_user.id)
-    log_audit("directory_batch_started", user_id=current_user.id, details=f"batch_id={batch_id}, files={len(dcm_paths)}")
-    return redirect(url_for("batch_progress", batch_id=batch_id))
+    try:
+        batch_id = _start_batch(dcm_paths, current_user.id)
+        log_audit(
+            "directory_batch_started",
+            user_id=current_user.id,
+            details=f"batch_id={batch_id}, files={len(dcm_paths)}",
+        )
+        return redirect(url_for("batch_progress", batch_id=batch_id))
+    except Exception:
+        logger.error("Celery unavailable; running synchronous directory scan", exc_info=True)
+        flash("Celery worker unavailable. Running directory scan synchronously.", "warning")
+        result = _run_batch_sync(dcm_paths, current_user.id)
+        flash(
+            f"Directory scan complete: {result['succeeded']}/{result['total']} succeeded.",
+            "info",
+        )
+        return redirect(url_for("reports"))
 
 @app.route("/batch/<batch_id>")
 @login_required
 def batch_progress(batch_id):
     """Batch processing progress page"""
-    with _BATCHES_LOCK:
-        batch = _BATCHES.get(batch_id)
-        if not batch or batch.get("user_id") != current_user.id:
-            abort(404)
-        batch_copy = dict(batch)
+    batch = _get_batch_from_celery(batch_id)
+    if not batch or batch.get("user_id") != current_user.id:
+        abort(404)
     
-    return render_template("batch_progress.html", batch=batch_copy, batch_id=batch_id)
+    return render_template("batch_progress.html", batch=batch, batch_id=batch_id)
 
 @app.route("/batch/<batch_id>/status")
 @login_required
 def batch_status(batch_id):
     """Get batch status (JSON API)"""
-    with _BATCHES_LOCK:
-        batch = _BATCHES.get(batch_id)
-        if not batch or batch.get("user_id") != current_user.id:
-            return jsonify({"error": "Not found"}), 404
-        return jsonify(batch)
+    batch = _get_batch_from_celery(batch_id)
+    if not batch or batch.get("user_id") != current_user.id:
+        return jsonify({"error": "Not found"}), 404
+    return jsonify(batch)
 
+def _get_batch_from_celery(batch_id: str) -> dict[str, Any] | None:
+    """Retrieve batch status from Celery task result backend."""
+    # In a production system, we'd also validate user_id from the database
+    # For now, we rely on Celery returning task metadata with user_id in meta dict
+    queue_size = _get_queue_depth()
+    
+    # Try to find the task associated with this batch_id
+    # Celery doesn't provide a direct "get by batch_id" so we query the backend
+    result = AsyncResult(batch_id, app=celery_app)
+    user_id = _extract_user_id_from_batch_id(batch_id)
+    
+    if result.state == "PENDING" and not result.info:
+        # Task has been queued but has not written progress yet.
+        return {
+            "batch_id": batch_id,
+            "user_id": user_id,
+            "status": "pending",
+            "total": 0,
+            "processed": 0,
+            "succeeded": 0,
+            "failed_ids": [],
+            "image_ids": [],
+            "current_file": "",
+            "started_at": None,
+            "finished_at": None,
+            "error": None,
+            "queue_size": queue_size,
+        }
+    
+    # Build response matching _BATCHES format for frontend compatibility
+    if result.state == "PROGRESS":
+        meta = result.info or {}
+        return {
+            "batch_id": meta.get("batch_id", batch_id),
+            "user_id": meta.get("user_id", user_id),
+            "status": meta.get("status", "running"),
+            "total": meta.get("total", 0),
+            "processed": meta.get("processed", 0),
+            "succeeded": meta.get("succeeded", 0),
+            "failed_ids": meta.get("failed_ids", []),
+            "image_ids": meta.get("image_ids", []),
+            "current_file": meta.get("current_file", ""),
+            "started_at": meta.get("started_at"),
+            "finished_at": meta.get("finished_at"),
+            "error": meta.get("error"),
+            "queue_size": meta.get("queue_size", queue_size),
+        }
+    elif result.state == "SUCCESS":
+        # Task completed
+        return result.result if isinstance(result.result, dict) else {
+            "batch_id": batch_id,
+            "user_id": user_id,
+            "status": "completed",
+            "error": None,
+            "queue_size": queue_size,
+        }
+    elif result.state == "FAILURE":
+        # Task failed
+        return {
+            "batch_id": batch_id,
+            "user_id": user_id,
+            "status": "failed",
+            "error": str(result.info) if result.info else "Unknown error",
+            "queue_size": queue_size,
+        }
+    elif result.state == "REVOKED":
+        return {
+            "batch_id": batch_id,
+            "user_id": user_id,
+            "status": "revoked",
+            "error": "Task was revoked",
+            "queue_size": queue_size,
+        }
+    else:
+        # PENDING or other states
+        return {
+            "batch_id": batch_id,
+            "user_id": user_id,
+            "status": "pending",
+            "error": None,
+            "queue_size": queue_size,
+        }
 @app.route("/reports")
 @login_required
 def reports():
@@ -854,58 +1125,171 @@ def reports():
         data_cache_hit=False,
     )
 
+
+@app.route("/report/<image_id>/delete", methods=["POST"])
+@login_required
+def delete_report(image_id):
+    """Delete a single report and its associated files for the current user."""
+    report = ScreeningReport.query.filter_by(user_id=current_user.id, image_id=image_id).first()
+    if not report:
+        flash("Report not found", "error")
+        return redirect(url_for("reports"))
+
+    reports_dir = UserDataManager().get_user_reports_dir(current_user.id)
+    try:
+        for path in reports_dir.glob(f"{image_id}*"):
+            try:
+                path.unlink()
+            except OSError:
+                logger.warning(f"Failed to delete file: {path}")
+    except Exception:
+        logger.exception("Error while removing report files")
+
+    try:
+        db.session.delete(report)
+        db.session.commit()
+    except Exception:
+        db.session.rollback()
+        logger.exception("Failed to delete report DB entry")
+        flash("Failed to delete report", "error")
+        return redirect(url_for("reports"))
+
+    log_audit("report_deleted", user_id=current_user.id, resource_type="report", resource_id=report.id)
+    flash("Report deleted", "success")
+    return redirect(url_for("reports"))
+
+
+@app.route("/reports/delete_all", methods=["POST"])
+@login_required
+def delete_all_reports():
+    """Delete all reports and local files for the current user."""
+    reports = ScreeningReport.query.filter_by(user_id=current_user.id).all()
+    reports_dir = UserDataManager().get_user_reports_dir(current_user.id)
+
+    # Remove files
+    try:
+        for path in reports_dir.iterdir():
+            if path.is_file():
+                try:
+                    path.unlink()
+                except OSError:
+                    logger.warning(f"Failed to delete file: {path}")
+    except Exception:
+        logger.exception("Error while removing user report files")
+
+    # Remove DB entries
+    try:
+        for r in reports:
+            db.session.delete(r)
+        db.session.commit()
+    except Exception:
+        db.session.rollback()
+        logger.exception("Failed to delete report DB entries")
+        flash("Failed to delete all reports", "error")
+        return redirect(url_for("reports"))
+
+    log_audit("reports_deleted_all", user_id=current_user.id, resource_type="report", resource_id=None)
+    flash("All reports deleted", "success")
+    return redirect(url_for("reports"))
+
 @app.route("/case/<image_id>")
 @login_required
 def case_detail(image_id):
     """View screening report details"""
-    report_record = ScreeningReport.query.filter_by(user_id=current_user.id, image_id=image_id).first()
+    report = ScreeningReport.query.filter_by(user_id=current_user.id, image_id=image_id).first()
+    if not report:
+        abort(404)
     
-    user_reports_dir = UserDataManager(UPLOAD_BASE_DIR).get_user_reports_dir(current_user.id)
     report_data = None
-    if report_record and report_record.report_json_path:
-        rp = Path(BASE_DIR) / report_record.report_json_path
-        if rp.exists():
-            with open(rp, "r") as f:
+    if report.report_payload:
+        try:
+            report_data = json.loads(report.report_payload)
+        except json.JSONDecodeError:
+            report_data = None
+
+    if report_data is None:
+        user_reports_dir = UserDataManager().get_user_reports_dir(current_user.id)
+        report_path = user_reports_dir / f"{image_id}_report.json"
+        if not report_path.exists():
+            abort(404)
+        try:
+            with open(report_path) as f:
                 report_data = json.load(f)
+        except (json.JSONDecodeError, OSError):
+            abort(500)
+    
+    log_audit("report_viewed", user_id=current_user.id, resource_type="report", resource_id=report.id)
+    # Build a lightweight `row` object matching CaseRow used elsewhere so the
+    # detail template can access properties like `row.image_id`, `row.cal_prob`.
+    def _format_date(dt):
+        try:
+            return dt.isoformat()
+        except Exception:
+            return str(dt) if dt else ""
+
+    gradcam_ref = _resolve_gradcam_reference(report)
+    gradcam_url = None
+    if gradcam_ref:
+        if gradcam_ref.startswith("http"):
+            gradcam_url = gradcam_ref
+        else:
+            gradcam_url = url_for("serve_gradcam", filename=Path(gradcam_ref).name)
+
+    row = SimpleNamespace(
+        image_id=report.image_id,
+        outcome=report.screening_outcome or "Unknown",
+        raw_prob=report.raw_probability,
+        cal_prob=report.calibrated_probability,
+        band=report.confidence_band or "N/A",
+        triage=report.triage_action or "N/A",
+        urgency=report.urgency or "N/A",
+        generated_at=_format_date(report.generated_at),
+        date_display=(report.generated_at.strftime("%Y-%m-%d %H:%M") if report.generated_at else "—"),
+        report_file=Path(report.report_json_path).name if report.report_json_path else None,
+        gradcam_url=gradcam_url,
+        true_label=report.true_label,
+        is_positive=("no hemorrhage" not in (report.screening_outcome or "").lower()),
+    )
 
-    # Use existing record details or construct a CaseRow
-    if report_record:
-        g_url = report_record.gradcam_image_path
-        if not g_url:
-            fallback_path = user_reports_dir / f"{image_id}_gradcam.png"
-            if fallback_path.exists():
-                g_url = url_for('serve_gradcam', filename=fallback_path.name)
+    return render_template("detail.html", row=row, report_record=report, payload=report_data)
 
-        row = CaseRow(
-            image_id=image_id,
-            outcome=report_record.screening_outcome or "Unknown",
-            raw_prob=report_record.raw_probability,
-            cal_prob=report_record.calibrated_probability,
-            band=report_record.confidence_band or "N/A",
-            triage=report_record.triage_action or "N/A",
-            urgency=report_record.urgency or "N/A",
-            generated_at=report_record.generated_at.isoformat() if report_record.generated_at else "",
-            gradcam_url=g_url
-        )
+
+@app.route("/case/<image_id>/ground-truth", methods=["POST"])
+@login_required
+def update_ground_truth(image_id):
+    """Update ground truth label for a report."""
+    report = ScreeningReport.query.filter_by(user_id=current_user.id, image_id=image_id).first()
+    if not report:
+        abort(404)
+
+    raw_value = (request.form.get("true_label") or "").strip()
+    normalized = raw_value.upper().replace(" ", "_").replace("/", "_")
+    allowed = {"POSITIVE", "NEGATIVE", "UNKNOWN", "N_A"}
+    if not normalized or normalized == "N_A":
+        report.true_label = None
+    elif normalized not in allowed:
+        flash("Invalid ground truth value.", "error")
+        return redirect(url_for("case_detail", image_id=image_id))
     else:
-        # fallback
-        row = CaseRow(
-            image_id=image_id, outcome="Unknown", raw_prob=None, cal_prob=None,
-            band="N/A", triage="N/A", urgency="N/A", generated_at=""
-        )
+        report.true_label = "UNKNOWN" if normalized == "UNKNOWN" else normalized
 
-    return render_template(
-        "detail.html",
-        image_id=image_id,
-        row=row,
-        payload=report_data,
-        report_record=report_record
-    )
+    try:
+        db.session.commit()
+        log_audit("ground_truth_updated", user_id=current_user.id, resource_type="report", resource_id=report.id)
+        flash("Ground truth updated.", "success")
+    except Exception:
+        db.session.rollback()
+        logger.exception("Failed to update ground truth")
+        flash("Failed to update ground truth.", "error")
+
+    return redirect(url_for("case_detail", image_id=image_id))
 
 @app.route("/logs")
 @login_required
 def logs_page():
     """View user's inference logs"""
+    if not SHOW_LOGS:
+        abort(404)
     log_files = []
     
     if LOGS_DIR.exists():
@@ -928,6 +1312,7 @@ def about():
 def evaluation():
     """Model evaluation page"""
     cases = _load_user_cases(current_user.id) if current_user.is_authenticated else []
+    gt_stats = _compute_ground_truth_stats(current_user.id) if current_user.is_authenticated else None
     cal_probs = [r.cal_prob for r in cases if r.cal_prob is not None]
 
     bins = [0] * 10
@@ -952,6 +1337,7 @@ def evaluation():
         bins=bins,
         band_data=band_data,
         total=len(cases),
+        gt_stats=gt_stats,
     )
 
 
@@ -960,69 +1346,25 @@ def evaluation():
 def serve_gradcam(filename: str):
     """Serve a user's Grad-CAM image from their report directory."""
     safe_name = Path(filename).name
-    reports_dir = UserDataManager(UPLOAD_BASE_DIR).get_user_reports_dir(current_user.id)
+    reports_dir = UserDataManager().get_user_reports_dir(current_user.id)
     return send_from_directory(reports_dir, safe_name)
 
-@app.route("/report/<path:filename>")
+@app.route("/report-json/<path:filename>")
 @login_required
 def serve_report_json(filename: str):
-    """Serve a user's JSON report."""
+    """Serve a user's report JSON file from their report directory."""
     safe_name = Path(filename).name
-    reports_dir = UserDataManager(UPLOAD_BASE_DIR).get_user_reports_dir(current_user.id)
-    return send_from_directory(reports_dir, safe_name)
+    reports_dir = UserDataManager().get_user_reports_dir(current_user.id)
+    report_path = reports_dir / safe_name
+    if report_path.exists():
+        return send_from_directory(reports_dir, safe_name, mimetype="application/json")
 
-@app.route("/report/<image_id>/delete", methods=["POST"])
-@login_required
-def delete_report(image_id: str):
-    """Delete a single screening report and its local files."""
+    image_id = safe_name.replace("_report.json", "")
     report = ScreeningReport.query.filter_by(user_id=current_user.id, image_id=image_id).first()
-    if not report:
-        flash("Report not found.", "error")
-        return redirect(url_for("reports"))
-
-    # Delete local files
-    user_reports_dir = UserDataManager(UPLOAD_BASE_DIR).get_user_reports_dir(current_user.id)
-    for suffix in ("_report.json", "_gradcam.png", "_preview.png"):
-        fp = user_reports_dir / f"{image_id}{suffix}"
-        fp.unlink(missing_ok=True)
-
-    # Delete associated upload record
-    if report.upload_id:
-        upload = db.session.get(ScreeningUpload, report.upload_id)
-        if upload:
-            db.session.delete(upload)
-        else:
-            db.session.delete(report)
-    else:
-        db.session.delete(report)
+    if report and report.report_payload:
+        return Response(report.report_payload, mimetype="application/json")
 
-    db.session.commit()
-    log_audit("report_deleted", user_id=current_user.id, resource_type="report", resource_id=image_id)
-    flash(f"Report {image_id} deleted.", "success")
-    return redirect(url_for("reports"))
-
-
-@app.route("/reports/delete-all", methods=["POST"])
-@login_required
-def delete_all_reports():
-    """Delete ALL reports for the current user quickly."""
-    import shutil
-    
-    # 1. Delete physical files securely by dropping the entire user reports folder
-    user_reports_dir = UserDataManager(UPLOAD_BASE_DIR).get_user_reports_dir(current_user.id)
-    shutil.rmtree(user_reports_dir, ignore_errors=True)
-    user_reports_dir.mkdir(parents=True, exist_ok=True)
-    
-    # 2. Bulk delete database records
-    # Because of cascade rules, deleting uploads will automatically delete reports too.
-    # But to be completely safe, we can delete reports directly as well.
-    report_count = db.session.query(ScreeningReport).filter_by(user_id=current_user.id).delete()
-    upload_count = db.session.query(ScreeningUpload).filter_by(user_id=current_user.id).delete()
-    
-    db.session.commit()
-    log_audit("all_reports_deleted", user_id=current_user.id, resource_type="report", resource_id="all")
-    flash(f"All {report_count} reports and their files have been deleted.", "success")
-    return redirect(url_for("reports"))
+    abort(404)
 
 @app.errorhandler(401)
 def unauthorized(e):
@@ -1063,8 +1405,6 @@ def init_db_cmd():
 @app.cli.command()
 def create_admin():
     """Create admin user (interactive)"""
-    from getpass import getpass
-    
     username = input("Username: ").strip()
     email = input("Email: ").strip()
     password = getpass("Password: ")

auth_routes.py

@@ -116,83 +116,29 @@ def _validate_otp(submitted_code: str, expected_purpose: str) -> tuple[bool, str
     return True, "", payload
 
 
-def _otp_email_content(code: str, purpose: str) -> tuple[str, str]:
-    """Return (plain_text, html) for OTP emails."""
+def _otp_body(code: str, purpose: str) -> str:
     if purpose == "verify_email":
         title = "Verify your ICH Screening account"
-        body_line = (
-            "Welcome to ICH Screening. You're one step away from accessing our platform.\n"
-            "Enter the verification code below to confirm your email address and activate your account."
-        )
     else:
         title = "Your ICH Screening verification code"
-        body_line = (
-            "A verification code was requested for your ICH Screening account.\n"
-            "Enter the code below to continue. If this wasn't you, your account remains secure."
-        )
-
-    plain = (
-        f"{title}\n"
-        f"{'=' * len(title)}\n\n"
-        f"Hi there,\n\n"
-        f"{body_line}\n\n"
-        f"  Verification Code: {code}\n"
-        f"  Valid for: 10 minutes\n\n"
-        "Security reminder: ICH Screening will never ask you to share this code "
-        "over the phone, email, or chat. If anyone requests it, treat it as a phishing attempt.\n\n"
-        "Didn't sign up? Simply ignore this email — your account will remain inactive "
-        "unless this code is entered.\n"
-    )
-
-    try:
-        from flask import render_template
-        html = render_template(
-            "email/otp_email.html",
-            title=title,
-            otp_code=code,
-            purpose=purpose,
-            recipient_name=None,
-            current_year=datetime.utcnow().year,
-        )
-    except Exception as exc:
-        logger.warning("Could not render OTP HTML email template: %s", exc)
-        html = None
-
-    return plain, html
-
-
-def _password_reset_email_content(reset_link: str) -> tuple[str, str]:
-    """Return (plain_text, html) for password-reset emails."""
-    _reset_title = "ICH Screening — Password Reset"
-    plain = (
-        f"{_reset_title}\n"
-        f"{'─' * len(_reset_title)}\n\n"
-        "Hi there,\n\n"
-        "We received a request to reset the password for your ICH Screening account.\n"
-        "Use the link below to choose a new password — it only takes a moment.\n\n"
-        f"  Reset link: {reset_link}\n\n"
-        "This link is single-use and expires in 30 minutes.\n\n"
-        "Didn't request this? You can ignore this email — your password has not been\n"
-        "changed and your account remains intact.\n"
+    return (
+        f"{title}\n\n"
+        f"Your one-time password (OTP) is: {code}\n"
+        "This code expires in 10 minutes.\n\n"
+        "If you did not request this, you can ignore this email."
     )
 
-    try:
-        from flask import render_template
-        html = render_template(
-            "email/password_reset_email.html",
-            reset_link=reset_link,
-            recipient_name=None,
-            current_year=datetime.utcnow().year,
-        )
-    except Exception as exc:
-        logger.warning("Could not render password-reset HTML email template: %s", exc)
-        html = None
 
-    return plain, html
+def _password_reset_body(reset_link: str) -> str:
+    return (
+        "Reset your ICH Screening password\n\n"
+        f"Click the link below to set a new password:\n{reset_link}\n\n"
+        "This link expires in 30 minutes.\n"
+        "If you did not request this, you can ignore this email."
+    )
 
 
-def _send_email(to_email: str, subject: str, body: str, html_body: str | None = None) -> bool:
-    """Send a (optionally multipart HTML + plain-text) email via SMTP."""
+def _send_email(to_email: str, subject: str, body: str) -> bool:
     smtp_host = os.environ.get("SMTP_HOST", os.environ.get("EMAIL_HOST", "")).strip()
     smtp_user = os.environ.get("SMTP_USER", os.environ.get("EMAIL_HOST_USER", "")).strip()
     smtp_pass = os.environ.get("SMTP_PASSWORD", os.environ.get("EMAIL_HOST_PASSWORD", "")).strip()
@@ -211,11 +157,7 @@ def _send_email(to_email: str, subject: str, body: str, html_body: str | None =
     msg["Subject"] = subject
     msg["From"] = smtp_from
     msg["To"] = to_email
-    # Plain-text part (always present as fallback for non-HTML clients)
     msg.set_content(body)
-    # HTML alternative part (preferred by modern email clients when present)
-    if html_body:
-        msg.add_alternative(html_body, subtype="html")
 
     try:
         with smtplib.SMTP(smtp_host, smtp_port, timeout=20) as server:
@@ -301,12 +243,10 @@ def register():
             db.session.commit()
             
             otp_code = _store_otp(email=user.email, purpose="verify_email", user_id=user.id)
-            _plain, _html = _otp_email_content(otp_code, "verify_email")
             sent = _send_email(
                 user.email,
                 "Your ICH Screening verification code",
-                _plain,
-                html_body=_html,
+                _otp_body(otp_code, "verify_email"),
             )
             if _auth_email_debug_enabled():
                 logger.info("DEV OTP for %s: %s", user.email, otp_code)
@@ -356,12 +296,10 @@ def login():
         
         if not user.is_active:
             otp_code = _store_otp(email=user.email, purpose="verify_email", user_id=user.id)
-            _plain, _html = _otp_email_content(otp_code, "verify_email")
             sent = _send_email(
                 user.email,
                 "Your ICH Screening verification code",
-                _plain,
-                html_body=_html,
+                _otp_body(otp_code, "verify_email"),
             )
             if _auth_email_debug_enabled():
                 logger.info("DEV OTP resend/login for %s: %s", user.email, otp_code)
@@ -418,12 +356,10 @@ def forgot_password():
         if user:
             token = _token_serializer().dumps({"email": user.email, "purpose": "reset_password"})
             reset_link = _build_external_link('auth.reset_password', token=token)
-            _plain, _html = _password_reset_email_content(reset_link)
             sent = _send_email(
                 user.email,
                 'Reset your ICH Screening password',
-                _plain,
-                html_body=_html,
+                _password_reset_body(reset_link),
             )
             if _auth_email_debug_enabled():
                 logger.info("DEV reset link for %s: %s", user.email, reset_link)
@@ -490,8 +426,7 @@ def resend_otp():
     purpose = payload.get("purpose", "verify_email")
     user_id = payload.get("user_id")
     new_code = _store_otp(email=email, purpose=purpose, user_id=user_id)
-    _plain, _html = _otp_email_content(new_code, purpose)
-    sent = _send_email(email, "Your ICH Screening verification code", _plain, html_body=_html)
+    sent = _send_email(email, "Your ICH Screening verification code", _otp_body(new_code, purpose))
     if _auth_email_debug_enabled():
         logger.info("DEV OTP resend for %s: %s", email, new_code)
 

auth_utils.py

@@ -8,6 +8,7 @@ from flask import session, redirect, url_for, request, g, abort, has_request_con
 from flask_login import LoginManager, current_user
 from models import db, User, AuditLog
 from datetime import datetime
+from sqlalchemy.exc import SQLAlchemyError
 
 logger = logging.getLogger(__name__)
 
@@ -25,7 +26,22 @@ def init_auth(app):
 @login_manager.user_loader
 def load_user(user_id):
     """Load user from database by ID"""
-    return User.query.get(int(user_id))
+    try:
+        return User.query.get(int(user_id))
+    except SQLAlchemyError as e:
+        logger.warning(f"User loader failed, clearing session context: {e}")
+        try:
+            db.session.rollback()
+        except Exception:
+            pass
+        return None
+    except Exception as e:
+        logger.warning(f"Unexpected user loader failure: {e}")
+        try:
+            db.session.rollback()
+        except Exception:
+            pass
+        return None
 
 
 def get_client_ip():

models.py

@@ -88,6 +88,7 @@ class ScreeningReport(db.Model):
     # File paths (relative to user's data dir)
     report_json_path = db.Column(db.String(500))
     gradcam_image_path = db.Column(db.String(500))
+    report_payload = db.Column(db.Text)
     
     # Generated timestamp
     generated_at = db.Column(db.DateTime, default=datetime.utcnow, nullable=False, index=True)

requirements.txt

@@ -32,3 +32,8 @@ huggingface_hub>=0.17.0
 requests>=2.31.0
 python-dateutil>=2.8.0
 
+
+celery
+redis
+groq
+cloudinary

run_interface.py

@@ -241,6 +241,11 @@ def build_report(
 
     report["llm_summary"] = generate_medical_summary(inference, calib_cfg, report)
 
+    groq_api_key = os.environ.get("GROQ_API_KEY")
+    if Groq and groq_api_key:
+        report["llm_provider"] = "groq"
+        report["llm_model"] = os.environ.get("LLM_MODEL", "llama-3.1-8b-instant")
+
     # Cloudinary Integration
     cloud_name = os.environ.get("CLOUDINARY_CLOUD_NAME")
     api_key = os.environ.get("CLOUDINARY_API_KEY")

static/js/batch.js

@@ -10,6 +10,7 @@
 
     var title = document.getElementById('batchTitle');
     var subtitle = document.getElementById('batchSubtitle');
+    var queueStatus = document.getElementById('queueStatus');
     var fill = document.getElementById('progressFill');
     var pctLabel = document.getElementById('progressPct');
     var currentFile = document.getElementById('currentFile');
@@ -42,6 +43,16 @@
           statOK.textContent = data.succeeded;
           statFail.textContent = data.failed_ids ? data.failed_ids.length : 0;
 
+          if (queueStatus) {
+            if (typeof data.queue_size === 'number') {
+              queueStatus.textContent = 'Queue size: ' + data.queue_size;
+            } else if (data.status === 'pending') {
+              queueStatus.textContent = 'Queued for processing...';
+            } else {
+              queueStatus.textContent = '';
+            }
+          }
+
           fill.style.width = pct + '%';
           pctLabel.textContent = pct + '%';
           currentFile.textContent = data.current_file ? 'Processing: ' + data.current_file : '';

tasks.py

@@ -0,0 +1,260 @@
+"""
+Celery task workers for async inference and batch processing.
+Handles long-running DICOM processing jobs with progress tracking via Redis.
+
+Run worker with: celery -A tasks worker --loglevel=info
+"""
+
+import logging
+import os
+import shutil
+import datetime
+import ssl
+import sys
+import traceback
+from pathlib import Path
+from typing import Any
+
+# Ensure the app directory is in the Python path so imports work in worker processes
+APP_DIR = Path(__file__).parent.absolute()
+if str(APP_DIR) not in sys.path:
+    sys.path.insert(0, str(APP_DIR))
+
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+except ImportError:
+    pass
+
+from celery import Celery, current_task
+
+logger = logging.getLogger(__name__)
+
+# Extract Redis URL from environment
+REDIS_URL = os.environ.get("REDIS_URL", "redis://localhost:6379/0")
+
+# Initialize Celery app
+celery_app = Celery(
+    "ich_tasks",
+    broker=REDIS_URL,
+    backend=REDIS_URL,
+)
+
+# Configure Celery with SSL support for Upstash Redis
+ssl_config = None
+redis_backend_ssl = None
+if REDIS_URL.startswith("rediss://"):
+    ssl_config = {"ssl_cert_reqs": ssl.CERT_NONE}
+    redis_backend_ssl = {"ssl_cert_reqs": ssl.CERT_NONE}
+
+celery_app.conf.update(
+    broker_use_ssl=ssl_config,
+    redis_backend_use_ssl=redis_backend_ssl,
+    task_serializer="json",
+    accept_content=["json"],
+    result_serializer="json",
+    timezone="UTC",
+    enable_utc=True,
+    task_track_started=True,
+    task_time_limit=3600,  # 1 hour hard limit
+    task_soft_time_limit=3300,  # 55 min soft limit
+    result_expires=86400,  # 24 hours
+)
+
+
+@celery_app.task(bind=True, name="tasks.process_dicom_batch")
+def process_dicom_batch(
+    self,
+    batch_id: str,
+    dcm_paths: list[str],
+    user_id: int,
+    temp_dir: str | None = None,
+) -> dict[str, Any]:
+    """
+    Process a batch of DICOM files asynchronously with progress tracking.
+    
+    Args:
+        batch_id: Unique identifier for this batch job
+        dcm_paths: List of DICOM file paths to process
+        user_id: User ID for audit and data isolation
+        temp_dir: Optional temporary directory to clean up after
+    
+    Returns:
+        Dictionary with final batch status and results matching frontend expectations
+    """
+    # Import here to avoid circular imports. Add diagnostics to help debug
+    # ModuleNotFoundError issues when Celery workers can't find `app_new`.
+    try:
+        # Ensure APP_DIR is present in sys.path for worker subprocesses
+        if str(APP_DIR) not in sys.path:
+            sys.path.insert(0, str(APP_DIR))
+            logger.info(f"Inserted APP_DIR into sys.path: {APP_DIR}")
+        else:
+            logger.info(f"APP_DIR already in sys.path: {APP_DIR}")
+
+        logger.info(f"tasks.py APP_DIR={APP_DIR}")
+        logger.info(f"sys.path (first 10): {sys.path[:10]}")
+        # List files in the app dir for visibility
+        try:
+            files = [p.name for p in Path(APP_DIR).iterdir() if p.exists()]
+            logger.info(f"APP_DIR contents: {files[:50]}")
+        except Exception as _e:
+            logger.warning(f"Could not list APP_DIR contents: {_e}")
+
+        from app_new import app, _run_inference_on_dcm
+        from auth_utils import log_audit
+        from models import ScreeningUpload, db
+    except Exception as e:
+        logger.error("Failed importing application modules inside Celery worker:\n" + traceback.format_exc())
+        raise
+
+    total = len(dcm_paths)
+    succeeded_ids = []
+    failed_ids = []
+    started_at = datetime.datetime.now().isoformat()
+
+    logger.info(f"Batch {batch_id} starting: {total} files for user {user_id}")
+
+    try:
+        with app.app_context():
+            for i, path_str in enumerate(dcm_paths, 1):
+                # Check if task was revoked (compat across Celery versions)
+                request_ctx = current_task.request
+                is_revoked = bool(getattr(request_ctx, "is_revoked", False)) or bool(
+                    getattr(request_ctx, "revoked", False)
+                )
+                if is_revoked:
+                    logger.info(f"Batch {batch_id} revoked, stopping")
+                    break
+
+                path = Path(path_str)
+                image_id = path.stem
+
+                upload_record = ScreeningUpload(
+                    user_id=user_id,
+                    file_name=path.name,
+                    original_filename=path.name,
+                    file_size=path.stat().st_size if path.exists() else None,
+                    file_path=str(path),
+                    processing_status="processing",
+                )
+                db.session.add(upload_record)
+                db.session.commit()
+
+                # Update Celery task state with progress (matches _BATCHES format for frontend)
+                self.update_state(
+                    state="PROGRESS",
+                    meta={
+                        "batch_id": batch_id,
+                        "user_id": user_id,
+                        "status": "running",
+                        "total": total,
+                        "processed": i - 1,
+                        "succeeded": len(succeeded_ids),
+                        "failed_ids": list(failed_ids),
+                        "image_ids": list(succeeded_ids),
+                        "current_file": image_id,
+                        "started_at": started_at,
+                        "finished_at": None,
+                        "error": None,
+                        "temp_dir": temp_dir,
+                    },
+                )
+
+                try:
+                    report, _ = _run_inference_on_dcm(path, user_id, upload_record.id)
+                    if report:
+                        upload_record.processing_status = "completed"
+                        db.session.commit()
+                        succeeded_ids.append(image_id)
+                    else:
+                        upload_record.processing_status = "failed"
+                        db.session.commit()
+                        failed_ids.append(image_id)
+                except Exception as e:
+                    logger.error(f"Batch {batch_id}: failed {image_id} — {e}")
+                    db.session.rollback()
+                    upload_record.processing_status = "failed"
+                    try:
+                        db.session.commit()
+                    except Exception:
+                        db.session.rollback()
+                    failed_ids.append(image_id)
+
+                # Update after processing each file
+                self.update_state(
+                    state="PROGRESS",
+                    meta={
+                        "batch_id": batch_id,
+                        "user_id": user_id,
+                        "status": "running",
+                        "total": total,
+                        "processed": i,
+                        "succeeded": len(succeeded_ids),
+                        "failed_ids": list(failed_ids),
+                        "image_ids": list(succeeded_ids),
+                        "current_file": "",
+                        "started_at": started_at,
+                        "finished_at": None,
+                        "error": None,
+                        "temp_dir": temp_dir,
+                    },
+                )
+
+        # Cleanup temporary directory if provided
+        if temp_dir and Path(temp_dir).exists():
+            try:
+                shutil.rmtree(temp_dir, ignore_errors=True)
+                logger.info(f"Cleaned up temp_dir: {temp_dir}")
+            except Exception as e:
+                logger.warning(f"Failed to clean temp_dir {temp_dir}: {e}")
+
+        # Log final audit result
+        with app.app_context():
+            audit_status = "success" if len(failed_ids) == 0 else "partial"
+            log_audit(
+                "batch_processing_completed",
+                user_id=user_id,
+                details=f"batch_id={batch_id}, processed={total}, succeeded={len(succeeded_ids)}, failed={len(failed_ids)}",
+                status=audit_status,
+            )
+
+        # Return final result matching _BATCHES format for frontend compatibility
+        result = {
+            "batch_id": batch_id,
+            "user_id": user_id,
+            "status": "completed",
+            "total": total,
+            "processed": total,
+            "succeeded": len(succeeded_ids),
+            "failed_ids": list(failed_ids),
+            "image_ids": list(succeeded_ids),
+            "current_file": "",
+            "started_at": started_at,
+            "finished_at": datetime.datetime.now().isoformat(),
+            "error": None,
+            "temp_dir": temp_dir,
+        }
+
+        logger.info(
+            f"Batch {batch_id} complete: {len(succeeded_ids)}/{total} succeeded, "
+            f"{len(failed_ids)} failed"
+        )
+        return result
+
+    except Exception as e:
+        logger.error(f"Batch {batch_id} error: {e}", exc_info=True)
+        with app.app_context():
+            log_audit(
+                "batch_processing_failed",
+                user_id=user_id,
+                details=f"batch_id={batch_id}, error={str(e)}",
+                status="failure",
+            )
+        raise
+
+
+@celery_app.task(name="tasks.health_check")
+def health_check() -> str:
+    """Simple health check task for monitoring."""
+    return "Celery worker is healthy"

templates/404.html

@@ -3,7 +3,7 @@
 <head>
   <meta charset="utf-8"/>
   <meta name="viewport" content="width=device-width, initial-scale=1"/>
-  <title>Page Not Found — ICH Screening</title>
+  <title>Page Not Found — AI Medical Intelligence Pipeline</title>
   <meta name="description" content="The page you requested could not be found."/>
   <link rel="preconnect" href="https://fonts.googleapis.com"/>
   <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin/>
@@ -71,7 +71,7 @@
   </div>
 
   <p class="error-footer">
-    <a href="{{ url_for('home') }}">ICH Screening</a> — AI-Assisted CT Hemorrhage Detection
+    <a href="{{ url_for('home') }}">AI Medical Intelligence Pipeline</a> — CT Scan Analysis
   </p>
 </div>
 </body>

templates/500.html

@@ -3,7 +3,7 @@
 <head>
   <meta charset="utf-8"/>
   <meta name="viewport" content="width=device-width, initial-scale=1"/>
-  <title>Server Error — ICH Screening</title>
+  <title>Server Error — AI Medical Intelligence Pipeline</title>
   <meta name="description" content="An internal server error occurred. Our team has been notified."/>
   <link rel="preconnect" href="https://fonts.googleapis.com"/>
   <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin/>
@@ -69,7 +69,7 @@
   </div>
 
   <p class="error-footer">
-    <a href="{{ url_for('home') }}">ICH Screening</a> — AI-Assisted CT Hemorrhage Detection
+    <a href="{{ url_for('home') }}">AI Medical Intelligence Pipeline</a> — CT Scan Analysis
   </p>
 </div>
 </body>

templates/about.html

@@ -1,13 +1,13 @@
 {% extends "base.html" %}
 
-{% block title %}About — ICH Screening{% endblock %}
+{% block title %}About — AI Medical Intelligence Pipeline{% endblock %}
 
 {% block content %}
 <section class="hero">
   <div class="hero-text">
     <h1>About This System</h1>
     <p>
-      AI-Assisted CT-Based Intracranial Hemorrhage Detection with Explainability
+      AI Medical Intelligence Pipeline for CT Scan Analysis with Explainability
       and Clinical Reporting
     </p>
   </div>
@@ -17,8 +17,8 @@
 <section class="panel">
   <h3>System Overview</h3>
   <p>
-    This is an AI-assisted screening tool designed to detect intracranial
-    hemorrhage (ICH) from CT brain scans. It combines deep learning with visual
+    This is an AI medical intelligence pipeline designed to analyze CT brain
+    scans for intracranial hemorrhage (ICH). It combines deep learning with visual
     explainability, confidence calibration, and structured clinical reporting to
     support — not replace — medical decision-making.
   </p>

templates/auth/login.html

@@ -3,8 +3,8 @@
 <head>
   <meta charset="utf-8"/>
   <meta name="viewport" content="width=device-width, initial-scale=1"/>
-  <title>Login — ICH Screening</title>
-  <meta name="description" content="Sign in to the ICH Screening AI dashboard."/>
+  <title>Login — AI Medical Intelligence Pipeline</title>
+  <meta name="description" content="Sign in to the AI Medical Intelligence Pipeline dashboard."/>
   <link rel="preconnect" href="https://fonts.googleapis.com"/>
   <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin/>
   <link href="https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700;800&display=swap" rel="stylesheet"/>
@@ -22,7 +22,7 @@
           <path d="M22 12h-4l-3 9L9 3l-3 9H2"/>
         </svg>
       </div>
-      <span class="auth-brand-name">ICH Screening</span>
+      <span class="auth-brand-name">AI Medical Intelligence Pipeline</span>
     </div>
 
     <div class="auth-headline">
@@ -35,7 +35,7 @@
         <span class="feat-icon">
           <svg width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="3"/><path d="M12 1v4M12 19v4M4.22 4.22l2.83 2.83M16.95 16.95l2.83 2.83M1 12h4M19 12h4M4.22 19.78l2.83-2.83M16.95 7.05l2.83-2.83"/></svg>
         </span>
-        Deep learning ICH classification
+        AI medical intelligence for CT analysis
       </li>
       <li>
         <span class="feat-icon">
@@ -185,7 +185,7 @@
       </form>
 
       <div class="auth-footer">
-        New to ICH Screening? <a href="{{ url_for('auth.register') }}">Create a free account</a>
+        New to the pipeline? <a href="{{ url_for('auth.register') }}">Create a free account</a>
       </div>
     </div>
   </main>

templates/auth/reset_password.html

@@ -3,7 +3,7 @@
 <head>
   <meta charset="utf-8"/>
   <meta name="viewport" content="width=device-width, initial-scale=1"/>
-  <title>Reset Password — ICH Screening</title>
+  <title>Reset Password — AI Medical Intelligence Pipeline</title>
   <meta name="description" content="Set a new password for your account."/>
   <link rel="preconnect" href="https://fonts.googleapis.com"/>
   <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin/>
@@ -20,7 +20,7 @@
           <path d="M22 12h-4l-3 9L9 3l-3 9H2"/>
         </svg>
       </div>
-      <span class="auth-brand-name">ICH Screening</span>
+      <span class="auth-brand-name">AI Medical Intelligence Pipeline</span>
     </div>
 
     <div class="auth-headline">

templates/auth/verify_otp.html

@@ -3,7 +3,7 @@
 <head>
   <meta charset="utf-8"/>
   <meta name="viewport" content="width=device-width, initial-scale=1"/>
-  <title>Verify Email OTP — ICH Screening</title>
+  <title>Verify Email OTP — AI Medical Intelligence Pipeline</title>
   <meta name="description" content="Verify your email with one-time password."/>
   <link rel="preconnect" href="https://fonts.googleapis.com"/>
   <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin/>
@@ -20,7 +20,7 @@
           <path d="M22 12h-4l-3 9L9 3l-3 9H2"/>
         </svg>
       </div>
-      <span class="auth-brand-name">ICH Screening</span>
+      <span class="auth-brand-name">AI Medical Intelligence Pipeline</span>
     </div>
 
     <div class="auth-headline">
@@ -29,7 +29,7 @@
     </div>
 
     <ul class="auth-features">
-      <li><span class="feat-icon">1</span>Open the email from ICH Screening</li>
+      <li><span class="feat-icon">1</span>Open the email from the AI Medical Intelligence Pipeline</li>
       <li><span class="feat-icon">2</span>Copy the 6-digit code</li>
       <li><span class="feat-icon">3</span>Enter it here — valid for 10 minutes</li>
     </ul>

templates/base.html

@@ -3,7 +3,7 @@
   <head>
     <meta charset="utf-8" />
     <meta name="viewport" content="width=device-width, initial-scale=1" />
-    <title>{% block title %}ICH Screening Dashboard{% endblock %}</title>
+    <title>{% block title %}AI Medical Intelligence Pipeline{% endblock %}</title>
     <link rel="preconnect" href="https://fonts.googleapis.com" />
     <link rel="preconnect" href="https://fonts.gstatic.com" crossorigin />
     <link
@@ -36,7 +36,7 @@
               <path d="M22 12h-4l-3 9L9 3l-3 9H2" />
             </svg>
           </span>
-          <span>ICH Screening</span>
+          <span>AI Medical Intelligence Pipeline</span>
         </a>
 
         <nav class="nav-links">
@@ -47,8 +47,10 @@
                class="{% if request.endpoint == 'upload' %}active{% endif %}">New Scan</a>
             <a href="{{ url_for('reports') }}"
                class="{% if request.endpoint == 'reports' %}active{% endif %}">Past Reports</a>
+            {% if show_logs %}
             <a href="{{ url_for('logs_page') }}"
-               class="{% if request.endpoint == 'logs_page' %}active{% endif %}">Logs</a>
+              class="{% if request.endpoint == 'logs_page' %}active{% endif %}">Logs</a>
+            {% endif %}
             <a href="{{ url_for('evaluation') }}"
                class="{% if request.endpoint == 'evaluation' %}active{% endif %}">Evaluation</a>
             <a href="{{ url_for('about') }}"
@@ -89,7 +91,7 @@
     <footer class="footer">
       <div class="container footer-inner">
         <p>
-          AI-Assisted CT-Based Intracranial Hemorrhage Detection &mdash;
+          AI Medical Intelligence Pipeline for CT Scan Analysis &mdash;
           Screening Tool, Not a Diagnostic Device
         </p>
         <p class="muted small">

templates/batch_progress.html

@@ -1,6 +1,6 @@
 {% extends "base.html" %}
 
-{% block title %}Batch Processing — ICH Screening{% endblock %}
+{% block title %}Batch Processing — AI Medical Intelligence Pipeline{% endblock %}
 
 {% block content %}
 <div class="batch-page" data-batch-id="{{ batch_id }}" data-status-url="{{ url_for('batch_status', batch_id=batch_id) }}" data-reports-url="{{ url_for('reports') }}">
@@ -17,6 +17,11 @@
   <p class="muted" id="batchSubtitle">
     Analyzing {{ batch.total }} DICOM file{{ 's' if batch.total != 1 }} — please keep this page open.
   </p>
+  <p class="muted" id="queueStatus">
+    {% if batch.queue_size is not none %}
+      Queue size: {{ batch.queue_size }}
+    {% endif %}
+  </p>
 </section>
 
 <!-- ── Progress bar ────────────────────────────────────────────────── -->

templates/detail.html

@@ -89,6 +89,19 @@
       </div>
     </div>
 
+    <form method="post" action="{{ url_for('update_ground_truth', image_id=row.image_id) }}" style="margin-top: 12px">
+      <label class="muted small" for="trueLabel">Update Ground Truth</label>
+      <div class="dir-input-row" style="margin-top: 6px">
+        <select name="true_label" id="trueLabel" class="input" style="max-width: 240px">
+          <option value="" {% if not row.true_label %}selected{% endif %}>Not set</option>
+          <option value="POSITIVE" {% if row.true_label == 'POSITIVE' %}selected{% endif %}>Positive</option>
+          <option value="NEGATIVE" {% if row.true_label == 'NEGATIVE' %}selected{% endif %}>Negative</option>
+          <option value="UNKNOWN" {% if row.true_label == 'UNKNOWN' %}selected{% endif %}>Unknown</option>
+        </select>
+        <button type="submit" class="btn btn-primary" style="margin-left: 8px">Save</button>
+      </div>
+    </form>
+
     <!-- Confidence bar -->
     {% if row.cal_prob is not none %}
     <div class="prob-bar-wrap">
@@ -143,6 +156,22 @@
 </section>
 {% endif %}
 
+{% if payload and (payload.llm_provider or payload.llm_model) %}
+<section class="panel" style="margin-top: 16px">
+  <h3>LLM Information</h3>
+  <div class="kv-group" style="max-width: 500px">
+    <div class="kv">
+      <span>Provider</span>
+      <strong>{{ payload.llm_provider or 'N/A' }}</strong>
+    </div>
+    <div class="kv">
+      <span>Model</span>
+      <strong>{{ payload.llm_model or 'N/A' }}</strong>
+    </div>
+  </div>
+</section>
+{% endif %}
+
 <!-- Model info (from payload) -->
 {% if payload and payload.screening_module %}
 <section class="panel" style="margin-top: 16px">

templates/evaluation.html

@@ -1,6 +1,6 @@
 {% extends "base.html" %}
 
-{% block title %}Evaluation — ICH Screening{% endblock %}
+{% block title %}Evaluation — AI Medical Intelligence Pipeline{% endblock %}
 
 {% block content %}
 <section class="hero">
@@ -182,4 +182,33 @@
     </div>
   </div>
 </section>
+
+{% if gt_stats %}
+<section class="panel" style="margin-top: 16px">
+  <h3>Ground Truth Agreement</h3>
+  {% if gt_stats.total == 0 %}
+  <p class="muted small">No ground truth labels available yet.</p>
+  {% else %}
+  <div class="kv-group" style="max-width: 500px">
+    <div class="kv">
+      <span>Labeled Cases</span><strong>{{ gt_stats.total }}</strong>
+    </div>
+    <div class="kv">
+      <span>Accuracy</span>
+      <strong>{{ '%.1f'|format(gt_stats.accuracy * 100) }}%</strong>
+    </div>
+    <div class="kv">
+      <span>False Positive Rate</span>
+      <strong>{{ '%.1f'|format(gt_stats.fp_rate * 100) }}%</strong>
+    </div>
+    <div class="kv">
+      <span>TP / TN</span><strong>{{ gt_stats.tp }} / {{ gt_stats.tn }}</strong>
+    </div>
+    <div class="kv">
+      <span>FP / FN</span><strong>{{ gt_stats.fp }} / {{ gt_stats.fn }}</strong>
+    </div>
+  </div>
+  {% endif %}
+</section>
+{% endif %}
 {% endblock %}

templates/home.html

@@ -1,6 +1,6 @@
 {% extends "base.html" %}
 
-{% block title %}ICH Screening — Dashboard{% endblock %}
+{% block title %}AI Medical Intelligence Pipeline — Dashboard{% endblock %}
 
 {% block head %}
 <link rel="stylesheet" href="{{ url_for('static', filename='css/home.css') }}"/>
@@ -14,7 +14,7 @@
     <span class="badge-dot"></span>
     AI-Powered Screening
   </div>
-  <h1>Intracranial Hemorrhage<br><span class="hero-grad">Detection System</span></h1>
+  <h1>AI Medical Intelligence<br><span class="hero-grad">Pipeline for CT Analysis</span></h1>
   <p>
     Clinical-grade CT scan analysis powered by deep learning — with Grad-CAM visualisation,
     automated triage, and exportable PDF reports.
@@ -112,6 +112,7 @@
 
 <!-- ── Mini cards ── -->
 <section class="mini-cards">
+  {% if show_logs %}
   <a href="{{ url_for('logs_page') }}" class="mini-card">
     <div class="mini-card-icon">
       <svg width="22" height="22" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="1.8">
@@ -120,8 +121,9 @@
       </svg>
     </div>
     <h3>Execution Logs</h3>
-    <p class="muted small">{{ log_count }} inference trace{{ 's' if log_count != 1 }} recorded</p>
+    <p class="muted small">{{ log_count | default(0) }} inference trace{{ 's' if (log_count | default(0)) != 1 }} recorded</p>
   </a>
+  {% endif %}
 
   <a href="{{ url_for('evaluation') }}" class="mini-card">
     <div class="mini-card-icon">

templates/logs.html

@@ -1,6 +1,6 @@
 {% extends "base.html" %}
 
-{% block title %}ICH Screening — Execution Logs{% endblock %}
+{% block title %}AI Medical Intelligence Pipeline — Execution Logs{% endblock %}
 
 {% block content %}
 <section class="page-header">

templates/reports.html

@@ -1,6 +1,6 @@
 {% extends "base.html" %}
 
-{% block title %}Past Reports — ICH Screening{% endblock %}
+{% block title %}Past Reports — AI Medical Intelligence Pipeline{% endblock %}
 
 {% block content %}
 <section class="breadcrumb">

templates/upload.html

@@ -1,6 +1,6 @@
 {% extends "base.html" %}
 
-{% block title %}Upload Scan — ICH Screening{% endblock %}
+{% block title %}Upload Scan — AI Medical Intelligence Pipeline{% endblock %}
 
 {% block content %}
 <section class="breadcrumb">