initialize

.env.example

@@ -0,0 +1,18 @@
+# Flask app
+ICH_APP_DEBUG=1
+ICH_APP_PORT=7860
+ICH_SECRET_KEY=change-me-in-production
+
+# Upload limits (MB)
+ICH_MAX_UPLOAD_MB=2048
+
+# Runtime model selection
+# Values: ensemble | best | 0 | 1 | 2 | 3 | 4
+ICH_FOLD_SELECTION=ensemble
+
+# Local mode enables server-side directory scan route
+ICH_LOCAL_MODE=1
+
+# Logging level
+# Values: DEBUG | INFO | WARNING | ERROR
+ICH_LOG_LEVEL=INFO

.gitignore

@@ -0,0 +1,56 @@
+# Python bytecode and caches
+__pycache__/
+*.py[cod]
+*.so
+.pytest_cache/
+.mypy_cache/
+.ruff_cache/
+
+# Virtual environments
+.venv/
+venv/
+env/
+
+# Build and packaging
+build/
+dist/
+*.egg-info/
+
+# Local runtime data
+uploads/
+logs/
+*.log
+*.tmp
+*.temp
+
+# Local environment files
+.env
+.env.*
+!.env.example
+
+# Local databases / coverage
+*.db
+*.sqlite3
+.coverage
+.coverage.*
+htmlcov/
+coverage.xml
+
+# Generated inference artifacts
+download_imp/*
+download
+# Local downloaded data
+data/
+datasets/
+
+# Optional local artifact layout
+
+
+# Jupyter
+.ipynb_checkpoints/
+
+# OS / editor files
+.DS_Store
+Thumbs.db
+.vscode/
+.idea/

README.md

@@ -0,0 +1,567 @@
+# Major Project Documentation
+
+## Project Structure and Setup
+
+This repository is organized into clear functional sections:
+
+- `app.py`: Flask web application for upload, inference, browsing reports, and logs
+- `run_interface.py`: Compatibility adapter between the web app and model inference code
+- `download_imp/`: Model artifacts and core inference implementation
+- `templates/`: Jinja2 HTML templates for the web UI
+- `static/`: CSS assets
+- `logs/` and `uploads/`: Runtime folders created automatically
+
+### Quick Start
+
+1. Create and activate a Python virtual environment.
+1. Install dependencies:
+
+  ```bash
+  pip install -r requirements.txt
+  ```
+
+1. Create environment file:
+
+  ```bash
+  cp .env.example .env
+  ```
+
+1. Run the web app:
+
+  ```bash
+  python app.py
+  ```
+
+1. Open:
+
+  ```text
+  http://127.0.0.1:7860
+  ```
+
+### Notes
+
+- Model and calibration files are expected under `download_imp/`.
+- Generated reports are written to `download_imp/outputs/reports/`.
+- `.gitignore` excludes runtime/generated files to keep version control clean.
+
+### Fold Selection
+
+The web app supports configurable fold selection via `.env` / environment variable:
+
+```bash
+ICH_FOLD_SELECTION=ensemble
+```
+
+Supported values:
+
+- `ensemble` (default): loads all available folds and averages predictions
+- `best`: uses the best single fold from the performance report summary
+- `0` to `4`: force a specific fold
+
+Based on [B4_Performance_Report.md](B4_Performance_Report.md), per-fold any-AUC indicates fold `3` as the strongest single fold in that table.
+
+### GitHub Artifact Policy
+
+Model checkpoints and heavy binary artifacts are intentionally ignored for GitHub:
+
+- `download_imp/*.pth`
+- `download_imp/*.pkl`
+- `download_imp/outputs/`
+
+This keeps the repository lightweight and reproducible while allowing local/model-private inference.
+
+## AI-Assisted CT-Based Intracranial Hemorrhage Detection with Explainability and Clinical Reporting
+
+---
+
+## 1. Introduction
+
+**Intracranial hemorrhage (ICH)** is a life-threatening neurological condition caused by bleeding within the skull. It is one of the most critical forms of stroke and requires immediate medical attention. Delays in detection and intervention significantly increase the risk of mortality and long-term neurological damage.
+
+**Computed Tomography (CT)** imaging is the primary diagnostic tool used in emergency settings for detecting intracranial hemorrhage due to its speed, availability, and high sensitivity to bleeding. However, accurate interpretation of CT scans requires experienced radiologists and must often be performed under time pressure, especially in emergency departments with high patient volumes.
+
+Artificial intelligence has shown promise in assisting medical image interpretation. However, many AI-based solutions function as **black-box models** and focus solely on prediction accuracy, limiting their trustworthiness and clinical adoption. There is a need for an AI-assisted system that supports early screening while providing transparent and interpretable outputs to aid clinical decision-making.
+
+---
+
+## 2. Problem Statement
+
+Intracranial hemorrhage detection from CT brain scans is a critical yet time-sensitive task in emergency medical care. Although CT imaging is effective for identifying hemorrhage, timely and accurate interpretation depends heavily on the availability of skilled radiologists. In high-pressure or resource-constrained environments, delays or misinterpretations can adversely affect patient outcomes.
+
+Existing AI-based approaches for hemorrhage detection often emphasize binary predictions without sufficient explainability or clinical context. This lack of transparency makes it difficult for healthcare professionals to rely on AI outputs during screening and prioritization.
+
+**The problem addressed in this project** is the absence of an explainable, AI-assisted screening system that can detect intracranial hemorrhage from CT scans while providing interpretable visual evidence and structured clinical explanations to support medical professionals.
+
+> **Note:** The system is intended strictly as a screening and assistive tool, not as a diagnostic replacement for certified medical practitioners.
+
+---
+
+## 3. Objectives
+
+### Primary Objectives
+
+- To develop an AI-based system capable of detecting intracranial hemorrhage from CT brain images
+- To classify CT scans into clearly defined categories: **hemorrhage present** or **absent**
+- To assist emergency screening by prioritizing high-risk cases
+
+### Secondary Objectives
+
+- To integrate visual explainability techniques that highlight regions influencing the model's predictions
+- To generate structured, human-readable clinical reports summarizing findings
+- To evaluate model reliability with emphasis on **false-negative reduction**
+- To ensure ethical deployment as a decision-support system rather than a diagnostic authority
+
+---
+
+## 4. Scope of the Project
+
+### Included
+
+✅ CT brain image preprocessing and normalization  
+✅ Binary classification of intracranial hemorrhage presence  
+✅ Explainability using activation-based heatmaps  
+✅ Confidence-aware screening and structured reporting
+
+### Excluded
+
+❌ Stroke subtype classification beyond hemorrhage detection  
+❌ Treatment recommendation or diagnosis  
+❌ Real-time clinical deployment  
+❌ Integration with hospital information systems
+
+---
+
+## 5. Dataset Description
+
+The project utilizes publicly available CT brain imaging datasets from Kaggle, such as:
+
+**Primary datasets:**
+- RSNA Intracranial Hemorrhage Detection Dataset
+- CT Brain Hemorrhage Dataset
+
+These datasets contain labeled CT scan images indicating the presence or absence of intracranial hemorrhage, with some datasets also providing hemorrhage subtype annotations.
+
+Using public datasets ensures reproducibility, ethical compliance, and feasibility within academic constraints.
+
+---
+
+## 6. Methodology
+
+### 6.1 Data Preprocessing
+
+Preprocessing is essential to improve image quality and model performance:
+
+- Conversion of DICOM images to standardized formats where required
+- Image resizing to fixed resolution
+- **CT windowing (brain window)** to enhance hemorrhage visibility
+- Intensity normalization
+- Noise reduction and artifact handling
+- Data augmentation to improve generalization and mitigate class imbalance
+
+### 6.2 Model Development
+
+A **convolutional neural network (CNN)** is implemented using transfer learning.
+
+- Pretrained architectures such as **ResNet** or **EfficientNet** are adapted for CT image analysis
+- The final classification layer is modified for **binary output**:
+  - **Class 0**: No intracranial hemorrhage
+  - **Class 1**: Intracranial hemorrhage present
+- The model is trained using supervised learning with appropriate loss functions
+
+### 6.3 Evaluation Metrics
+
+Model performance is evaluated using clinically relevant metrics:
+
+- **Sensitivity (Recall)** – prioritized to reduce missed hemorrhage cases
+- Specificity
+- Precision
+- Confusion matrix analysis
+- Receiver Operating Characteristic (ROC) curve
+
+> **Note:** Accuracy alone is not treated as a sufficient indicator of clinical usefulness.
+
+---
+
+## 7. Explainability Module
+
+To ensure transparency and trustworthiness:
+
+- **Gradient-weighted Class Activation Mapping (Grad-CAM)** will be applied
+- Heatmaps are generated to visualize regions contributing to predictions
+- Highlighted areas are analyzed in relation to known hemorrhage patterns in CT images
+
+This module allows clinicians to visually verify AI decisions rather than relying solely on binary outputs.
+
+### 7.1 Explainability Quality Assurance
+
+To ensure the reliability of explainability outputs:
+
+- **Sanity checks** will be implemented (e.g., occlusion/perturbation tests) to verify Grad-CAM is not highlighting irrelevant borders, text markers, or artifacts
+- Failure cases where heatmaps are misleading will be documented
+- For a sample of True Positives, False Negatives, and False Positives, Grad-CAM overlays will include brief qualitative notes comparing:
+  - What the model highlights
+  - What a clinician would expect to see
+- This ensures visual evidence aligns with clinical reasoning
+
+---
+
+## 8. Confidence-Aware Screening
+
+Instead of a simple binary output, the system incorporates prediction confidence:
+
+- **High-confidence hemorrhage detection** → urgent attention
+- **Low-confidence predictions** → manual review recommendation
+
+This approach reflects real-world screening workflows and reduces over-reliance on automated decisions.
+
+### 8.1 Confidence Calibration
+
+To ensure clinicians can trust the confidence scores:
+
+- **Calibration techniques** will be applied (e.g., temperature scaling or isotonic regression)
+- Both **raw probability** and **calibrated confidence** will be reported
+- Expected Calibration Error (ECE) will be evaluated
+- Three confidence bands will be defined:
+  - **High confidence**: urgent attention required
+  - **Medium confidence**: standard review
+  - **Low confidence**: manual review recommended
+- Error rates will be analyzed across each confidence band to support triage decisions
+
+---
+
+## 9. Clinical Report Generation
+
+A structured report generation module converts model outputs into human-readable explanations. Each report includes:
+
+- Screening outcome summary
+- Prediction confidence
+- Visual explainability reference
+- Clinical interpretation phrased as decision support
+
+The report avoids diagnostic claims and emphasizes assistive screening.
+
+### 9.1 Report Schema and Specifications
+
+To prevent diagnostic claims and ensure consistency:
+
+- A **fixed schema** will be defined with specific fields and allowed phrases
+- Reports will be locked down with rules to ensure they never make diagnostic claims
+- Each report field will have:
+  - **Screening outcome**: "Hemorrhage detected" or "No hemorrhage detected" (not "diagnosed")
+  - **Confidence level**: Numeric probability + calibrated confidence band
+  - **Visual evidence**: Reference to Grad-CAM heatmap image
+  - **Recommended action**: "Urgent radiologist review recommended" or "Standard review workflow"
+  - **System disclaimer**: Clear statement that this is a screening tool, not a diagnostic device
+- Standardized phrasing ensures clinical safety and legal compliance
+
+---
+
+## 10. System Architecture Overview
+
+```
+1. CT Brain Image Input
+   ↓
+2. Image Preprocessing Module
+   ↓
+3. CNN-Based Hemorrhage Detection Model
+   ↓
+4. Explainability Module (Grad-CAM)
+   ↓
+5. Confidence Assessment
+   ↓
+6. Structured Clinical Report Generator
+   ↓
+7. Output for Medical Review
+```
+
+---
+
+## 11. Technology Stack
+
+### Programming Language
+- **Python**
+
+### Libraries and Frameworks
+- **TensorFlow** or **PyTorch** (Deep Learning)
+- **OpenCV** (Image Processing)
+- **NumPy**, **Pandas** (Data Handling)
+- **Matplotlib** (Visualization)
+
+### Development Platform
+- **Kaggle Notebooks**
+- Jupyter Notebook
+
+---
+
+## 12. Feasibility and Resources
+
+The project is **fully feasible** using free computational resources:
+
+- Kaggle provides free GPU access suitable for CNN training
+- Transfer learning minimizes training time
+- All tools used are open-source
+- No specialized hardware is required locally
+
+**Kaggle provides:**
+- Free GPU access (time-limited but sufficient)
+- Adequate RAM and storage for medical imaging datasets
+- Stable notebook environment for training and evaluation
+
+**Constraints:**
+- Training time per session is limited
+- Efficient model selection and batch sizing are necessary
+
+These constraints align well with transfer learning-based approaches.
+
+---
+
+## 13. Ethical Considerations
+
+- The system is designed strictly as a **screening and decision-support tool**
+- It does not provide diagnosis or treatment recommendations
+- Limitations and potential biases are explicitly documented
+- Human oversight is required for all clinical decisions
+- Dataset usage complies with public research licenses
+- Model limitations and potential biases will be documented
+
+---
+
+## 14. Assumptions and Risks
+
+### Assumptions
+- Public datasets are representative of real-world CT brain images
+- Hemorrhage labels are clinically reliable and accurately annotated
+
+### Potential Risks
+- Class imbalance may bias predictions toward non-hemorrhage cases
+- Overfitting due to dataset limitations
+- Misinterpretation of AI outputs by non-expert users
+- False negatives could delay critical interventions
+
+### Clinical Risk Evaluation Protocol
+
+To address these risks systematically:
+
+- **Target operating points** will be defined (e.g., "maximize sensitivity subject to acceptable specificity")
+- **False negative analysis**: Pre-commit to reviewing all false negative cases with detailed inspection:
+  - Inspect FN scans with Grad-CAM overlays
+  - Document typical failure patterns (e.g., small bleeds, beam-hardening artifacts, post-operative changes)
+  - Use findings to refine preprocessing or model architecture
+- Each component of the system architecture will be evaluated using the framework:
+  - **Inputs** → **Outputs** → **Metrics** → **Failure Modes** → **Mitigations**
+- This structured approach ensures risks are systematically addressed before deployment
+
+Mitigation strategies will be implemented during development and documented in evaluation.
+
+---
+
+## 15. Proposed Experiments and Ablation Studies
+
+To validate design decisions and optimize performance, the following experiments will be conducted:
+
+### 15.1 Preprocessing Ablations
+
+**Goal**: Justify the preprocessing pipeline choices
+
+**Experiments**:
+- Brain windowing: ON vs OFF
+- Different normalization strategies (min-max, z-score, percentile-based)
+- Data augmentation: ON vs OFF
+
+**Evaluation metrics**:
+- Sensitivity (primary)
+- ROC-AUC
+- Expected Calibration Error (ECE)
+
+**Outcome**: Select preprocessing configuration that maximizes sensitivity while maintaining calibration
+
+### 15.2 Model Architecture Comparison
+
+**Goal**: Choose the optimal backbone architecture
+
+**Experiments**:
+- ResNet-50 vs EfficientNet-B0
+- Same train/validation split for fair comparison
+- Evaluate with fixed hyperparameters
+
+**Selection criteria**:
+- Sensitivity at fixed specificity (e.g., 95% specificity)
+- Inference time (important for screening/prioritization)
+- Model size and computational requirements
+
+**Outcome**: Select architecture based on clinical utility and deployment feasibility
+
+### 15.3 Confidence-Aware Triage Study
+
+**Goal**: Validate the three-band confidence system
+
+**Experiments**:
+- Define thresholds for high/medium/low confidence bands
+- Analyze case distribution across bands
+- Compute error rates (sensitivity, specificity, FN rate) per band
+
+**Metrics**:
+- Percentage of cases in each band
+- False negative rate by confidence level
+- Positive predictive value by confidence level
+
+**Outcome**: Demonstrate that high-confidence predictions are more reliable and support triage workflow
+
+### 15.4 Explainability Evaluation
+
+**Goal**: Validate that Grad-CAM provides clinically useful visualizations
+
+**Experiments**:
+- Generate Grad-CAM overlays for sample cases:
+  - True Positives (correct hemorrhage detection)
+  - False Negatives (missed hemorrhages)
+  - False Positives (false alarms)
+- Qualitative analysis comparing:
+  - What the model highlights
+  - What clinicians would expect to see
+- Document cases where heatmaps are misleading or incorrect
+
+**Outcome**: Ensure explainability module provides trustworthy visual evidence
+
+### 15.5 Calibration Study
+
+**Goal**: Improve confidence reliability
+
+**Experiments**:
+- Train baseline model and measure calibration (ECE, reliability diagram)
+- Apply temperature scaling and isotonic regression
+- Compare raw probabilities vs calibrated confidence
+
+**Outcome**: Deploy calibrated confidence scores that clinicians can trust
+
+---
+
+## 16. Expected Outcomes and Deliverables
+
+### 16.1 Expected Outcomes
+
+**Model Performance**:
+- A trained CNN model achieving high sensitivity (target: >95%) for intracranial hemorrhage detection
+- Specificity maintained at clinically acceptable levels (target: >85%)
+- Calibrated confidence scores with low Expected Calibration Error (ECE < 0.05)
+- Comprehensive performance evaluation across all metrics (sensitivity, specificity, precision, F1-score, ROC-AUC)
+
+**Explainability**:
+- Reliable Grad-CAM visualizations highlighting hemorrhage regions
+- Validated explainability outputs through sanity checks
+- Documented failure modes and typical misclassification patterns
+
+**Clinical Utility**:
+- Confidence-based triage system validated across three bands (high/medium/low)
+- Demonstrated reduction in false negatives through systematic review
+- Structured reports that support clinical decision-making without making diagnostic claims
+
+**Research Insights**:
+- Evidence-based justification for preprocessing choices through ablation studies
+- Model architecture comparison showing optimal choice for screening scenarios
+- Understanding of model limitations and failure patterns
+
+### 16.2 Project Deliverables
+
+**1. Trained Model**
+- Final CNN model weights saved in standard format (`.h5` or `.pth`)
+- Model configuration file documenting architecture and hyperparameters
+- Training history and learning curves
+
+**2. Preprocessing Pipeline**
+- Complete data preprocessing module for CT scan normalization
+- DICOM handling utilities where applicable
+- Data augmentation scripts
+
+**3. Explainability Module**
+- Grad-CAM implementation integrated with the model
+- Visualization generation scripts
+- Sanity check utilities for validation
+
+**4. Confidence Calibration Module**
+- Calibration implementation (temperature scaling/isotonic regression)
+- Scripts for computing calibrated confidence scores
+- Calibration evaluation metrics
+
+**5. Clinical Report Generator**
+- Structured report generation system with fixed schema
+- Template-based reporting following clinical safety guidelines
+- Sample reports demonstrating different scenarios
+
+**6. Evaluation Framework**
+- Complete evaluation scripts for all metrics
+- Confusion matrix and ROC curve generation
+- Ablation study implementation and results
+
+**7. Documentation**
+- Project report (this README and extended documentation)
+- Code documentation and inline comments
+- User guide for running the system
+- Dataset description and preprocessing details
+
+**8. Jupyter Notebooks**
+- Data exploration and preprocessing notebook
+- Model training and evaluation notebook
+- Explainability demonstration notebook
+- Report generation examples notebook
+
+**9. Results and Analysis**
+- Performance metrics across all experiments
+- Ablation study results with visualizations
+- Failure case analysis with Grad-CAM overlays
+- Calibration plots and reliability diagrams
+
+**10. Presentation Materials**
+- Project presentation slides
+- Demo video (optional)
+- Key visualizations and results summary
+
+---
+
+## 17. Limitations and Future Work
+
+### Current Limitations
+
+- **Dataset Scope**: Limited to publicly available datasets which may not fully represent all clinical scenarios
+- **Binary Classification**: Does not classify hemorrhage subtypes (epidural, subdural, subarachnoid, etc.)
+- **Single Slice Analysis**: May not utilize full 3D volumetric information from CT scans
+- **No Real-Time Deployment**: System is designed for research and demonstration, not clinical deployment
+- **Limited Clinical Validation**: Evaluation based on dataset labels, not verified by multiple radiologists
+
+### Future Enhancements
+
+**Clinical Extensions**:
+- Multi-class classification for hemorrhage subtypes
+- Integration of volumetric (3D) analysis using 3D CNNs
+- Temporal analysis for follow-up scan comparison
+- Integration with radiology workflow systems (PACS)
+
+**Technical Improvements**:
+- Ensemble models combining multiple architectures
+- Uncertainty quantification using Bayesian deep learning
+- Active learning for continuous model improvement
+- Real-time inference optimization for clinical deployment
+
+**Validation and Deployment**:
+- Prospective clinical validation with radiologist verification
+- Multi-center evaluation for generalizability
+- Regulatory compliance pathway (FDA/CE marking)
+- Production-ready deployment with monitoring
+
+**Enhanced Explainability**:
+- Multiple explainability methods comparison (Grad-CAM++, SHAP, attention mechanisms)
+- Interactive visualization tools for clinicians
+- Textual explanation generation describing detected features
+
+---
+
+## 18. Conclusion
+
+This project aims to develop an AI-assisted screening system for intracranial hemorrhage detection that prioritizes **clinical utility**, **explainability**, and **ethical deployment**. By combining deep learning with transparency mechanisms, confidence calibration, and structured reporting, the system is designed to support—not replace—clinical decision-making.
+
+The systematic approach to risk evaluation, comprehensive ablation studies, and focus on false negative reduction ensure that the system addresses real clinical needs while acknowledging its limitations as a screening tool.
+
+Through this project, we demonstrate that responsible AI in healthcare requires not just prediction accuracy, but also interpretability, calibration, careful validation, and explicit acknowledgment of system boundaries.
+
+---
+

app.py

@@ -0,0 +1,1119 @@
+"""
+ICH Screening Web Application
+==============================
+Features:
+  1. Upload a .dcm file -> run AI model -> display screening report
+  2. Browse past screening reports with date, outcome, band, urgency filters
+  3. View execution logs from inference runs
+
+Run:
+    python webapp/app.py
+    Open http://127.0.0.1:7860
+"""
+
+from __future__ import annotations
+import run_interface as ri
+import csv
+import datetime
+import json
+import math
+import logging
+import os
+import shutil
+import sys
+import tempfile
+import threading
+import time
+import uuid
+import zipfile
+from collections import Counter
+from dataclasses import dataclass, field
+from pathlib import Path
+from typing import Any
+
+try:
+    from dotenv import load_dotenv
+except Exception:
+    load_dotenv = None
+
+try:
+    import blackbox_recorder as bbr
+except Exception:
+    class _NoopRecorder:
+        def configure(self, **_kwargs):
+            return None
+
+        def start(self):
+            return None
+
+        def stop(self):
+            return None
+
+        def save_report(self, _path: str):
+            return None
+
+        def save_json(self, _path: str):
+            return None
+
+    bbr = _NoopRecorder()
+
+from flask import (
+    Flask, abort, flash, g, jsonify, redirect,
+    render_template, request, send_from_directory, url_for,
+)
+from werkzeug.utils import secure_filename
+
+
+# ══════════════════════════════════════════════════════════════════════════
+#  PATH CONFIGURATION
+# ══════════════════════════════════════════════════════════════════════════
+
+BASE_DIR    = Path(__file__).resolve().parent        # webapp/
+PROJECT_DIR = BASE_DIR                               # project root
+TEST_DIR    = BASE_DIR
+MODEL_DIR   = BASE_DIR / "download_imp"
+OUTPUT_DIR  = MODEL_DIR / "outputs"
+REPORTS_DIR = OUTPUT_DIR / "reports"
+SUMMARY_CSV = OUTPUT_DIR / "report_summary.csv"
+CALIB_JSON  = MODEL_DIR / "calibration_params.json"
+NORM_JSON   = MODEL_DIR / "normalization_stats.json"
+MODEL_PATH  = MODEL_DIR / "best_model_fold4.pth"
+UPLOAD_DIR  = BASE_DIR / "uploads"
+LOGS_DIR    = BASE_DIR / "logs"
+
+
+def _env_bool(name: str, default: bool) -> bool:
+    raw = os.environ.get(name)
+    if raw is None:
+        return default
+    return raw.strip().lower() in ("1", "true", "yes", "on")
+
+
+def _env_int(name: str, default: int, *, minimum: int | None = None) -> int:
+    raw = os.environ.get(name)
+    if raw is None:
+        return default
+    try:
+        value = int(raw)
+    except ValueError:
+        return default
+    if minimum is not None and value < minimum:
+        return default
+    return value
+
+
+# ══════════════════════════════════════════════════════════════════════════
+#  FLASK SETUP
+# ══════════════════════════════════════════════════════════════════════════
+
+if load_dotenv is not None:
+    load_dotenv(BASE_DIR / ".env")
+
+APP_DEBUG = _env_bool("ICH_APP_DEBUG", True)
+APP_PORT = _env_int("ICH_APP_PORT", 7860, minimum=1)
+MAX_UPLOAD_MB = _env_int("ICH_MAX_UPLOAD_MB", 2048, minimum=1)
+LOG_LEVEL_NAME = os.environ.get("ICH_LOG_LEVEL", "INFO").strip().upper()
+LOG_LEVEL = getattr(logging, LOG_LEVEL_NAME, logging.INFO)
+SECRET_KEY = os.environ.get("ICH_SECRET_KEY", "").strip()
+
+app = Flask(__name__, template_folder="templates", static_folder="static")
+app.secret_key = SECRET_KEY or os.urandom(24)
+app.config["MAX_CONTENT_LENGTH"] = MAX_UPLOAD_MB * 1024 * 1024
+
+# Local mode: enables server-side directory scanning.
+# Auto-detected (running from source) or forced via env var.
+LOCAL_MODE = _env_bool("ICH_LOCAL_MODE", True)
+
+logging.basicConfig(
+    level=LOG_LEVEL,
+    format="%(asctime)s | %(levelname)s | %(message)s",
+)
+logger = logging.getLogger("ich_app")
+
+
+# ══════════════════════════════════════════════════════════════════════════
+#  BLACKBOX RECORDER — traces inference function calls
+#
+#  We configure it once at module level.  start()/stop() bracket each
+#  inference run.  After each run, the trace is saved to logs/ as both a
+#  human-readable .txt and a structured .json.
+# ══════════════════════════════════════════════════════════════════════════
+
+LOGS_DIR.mkdir(parents=True, exist_ok=True)
+
+bbr.configure(
+    include=["run_interface", "app"],
+    capture_args=True,
+    capture_returns=True,
+    sampling_rate=1.0,
+)
+
+
+def _save_trace(image_id: str) -> dict:
+    """
+    Save the current blackbox trace to logs/ and return metadata about it.
+    Called immediately after bbr.stop().
+    """
+    ts = datetime.datetime.now().strftime("%Y%m%d_%H%M%S")
+    base = f"{ts}_{image_id}"
+    txt_path  = LOGS_DIR / f"{base}.txt"
+    json_path = LOGS_DIR / f"{base}.json"
+
+    try:
+        bbr.save_report(str(txt_path))
+    except Exception:
+        logger.warning("Could not save text trace for %s", image_id)
+
+    try:
+        bbr.save_json(str(json_path))
+    except Exception:
+        logger.warning("Could not save JSON trace for %s", image_id)
+
+    return {
+        "timestamp": ts,
+        "image_id":  image_id,
+        "txt_file":  txt_path.name if txt_path.exists() else None,
+        "json_file": json_path.name if json_path.exists() else None,
+    }
+
+
+# ══════════════════════════════════════════════════════════════════════════
+#  BATCH PROCESSING STATE
+#
+#  Each batch job is a background thread processing a list of .dcm paths.
+#  The UI polls /batch/status/<id> for live progress.
+# ══════════════════════════════════════════════════════════════════════════
+
+_BATCHES: dict[str, dict[str, Any]] = {}
+_BATCHES_LOCK = threading.Lock()
+
+
+def _new_batch(total: int, temp_dir: str | None = None) -> str:
+    """Create a fresh batch record and return its unique ID."""
+    batch_id = uuid.uuid4().hex[:12]
+    with _BATCHES_LOCK:
+        _BATCHES[batch_id] = {
+            "status":       "running",     # running | completed | failed
+            "total":        total,
+            "processed":    0,
+            "succeeded":    0,
+            "failed_ids":   [],
+            "current_file": "",
+            "image_ids":    [],            # successfully processed IDs
+            "started_at":   datetime.datetime.now().isoformat(),
+            "finished_at":  None,
+            "error":        None,
+            "temp_dir":     temp_dir,      # cleaned up after completion
+        }
+    return batch_id
+
+
+def _batch_update(batch_id: str, **kw):
+    """Thread-safe update of a batch record."""
+    with _BATCHES_LOCK:
+        if batch_id in _BATCHES:
+            _BATCHES[batch_id].update(kw)
+
+
+def _run_batch_worker(batch_id: str, dcm_paths: list[Path]):
+    """
+    Background thread: process a list of .dcm files sequentially.
+    Updates the batch record after each file for real-time UI feedback.
+    """
+    succeeded_ids: list[str] = []
+    failed_ids: list[str] = []
+
+    for i, path in enumerate(dcm_paths, 1):
+        image_id = path.stem
+        _batch_update(batch_id, current_file=image_id, processed=i - 1)
+
+        try:
+            report, _trace = _run_inference_on_dcm(path)
+            if report is not None:
+                succeeded_ids.append(image_id)
+            else:
+                failed_ids.append(image_id)
+        except Exception as e:
+            logger.error("Batch %s: failed %s — %s", batch_id, image_id, e)
+            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 temp directory if one was used (ZIP extraction)
+    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(),
+    )
+    # Force cache reload on next page view
+    _CACHE["data_signature"] = None
+    logger.info(
+        "Batch %s complete: %d/%d succeeded, %d failed",
+        batch_id, len(succeeded_ids), len(dcm_paths), len(failed_ids),
+    )
+
+
+def _start_batch(dcm_paths: list[Path], temp_dir: str | None = None) -> str:
+    """Create a batch job & launch its worker thread. Returns batch_id."""
+    batch_id = _new_batch(total=len(dcm_paths), temp_dir=temp_dir)
+    t = threading.Thread(
+        target=_run_batch_worker,
+        args=(batch_id, dcm_paths),
+        daemon=True,
+        name=f"batch-{batch_id}",
+    )
+    t.start()
+    return batch_id
+
+
+# ══════════════════════════════════════════════════════════════════════════
+#  IN-MEMORY CACHE
+# ══════════════════════════════════════════════════════════════════════════
+
+_CACHE: dict[str, Any] = {
+    "data_signature":       None,
+    "cases":                {},
+    "rows_sorted":          [],
+    "data_last_refresh_ms": None,
+    "data_last_cache_hit":  False,
+    "calib_signature":      None,
+    "calib":                {},
+    "norm_signature":       None,
+    "norm":                 {},
+}
+
+
+# ══════════════════════════════════════════════════════════════════════════
+#  MODEL STATE — lazy-loaded on first upload
+# ══════════════════════════════════════════════════════════════════════════
+
+_MODEL: dict[str, Any] = {
+    "loaded":        False,
+    "model":         None,
+    "grad_cam":      None,
+    "loaded_folds":  [],
+    "transform":     None,
+    "device":        None,
+    "temperature":   None,
+    "calib_cfg":     None,
+    "inference_mod": None,
+}
+
+
+def _ensure_model_loaded() -> bool:
+    """Lazy-load the ML model on first inference request."""
+    if _MODEL["loaded"]:
+        return True
+
+    try:
+        import torch
+
+        sys.path.insert(0, str(BASE_DIR))
+
+        device = "cuda" if torch.cuda.is_available() else "cpu"
+        fold_selection = os.environ.get("ICH_FOLD_SELECTION", "ensemble")
+
+        with open(CALIB_JSON) as f:
+            calib_cfg = json.load(f)
+
+        if NORM_JSON.exists():
+            with open(NORM_JSON) as f:
+                norm = json.load(f)
+            mean = norm.get("mean_3ch", [0.162136, 0.141483, 0.183675])
+            std = norm.get("std_3ch", [0.312067, 0.283885, 0.305968])
+        else:
+            mean, std = [0.485, 0.456, 0.406], [0.229, 0.224, 0.225]
+
+        models, grad_cams, loaded_folds = ri.load_runtime_models(device, fold_selection)
+        if not models:
+            logger.error("No fold checkpoints could be loaded from %s", MODEL_DIR)
+            return False
+
+        transform = ri.T.Compose([
+            ri.T.ToPILImage(),
+            ri.T.ToTensor(),
+            ri.T.Normalize(mean=mean, std=std),
+        ])
+
+        _MODEL.update({
+            "loaded":        True,
+            "model":         models,
+            "grad_cam":      grad_cams,
+            "loaded_folds":  loaded_folds,
+            "transform":     transform,
+            "device":        device,
+            "temperature":   float(calib_cfg.get("temperature", 1.0)),
+            "calib_cfg":     calib_cfg,
+            "inference_mod": ri,
+        })
+        logger.info(
+            "Model loaded (device=%s, fold_selection=%s, folds=%s)",
+            device,
+            fold_selection,
+            loaded_folds,
+        )
+        return True
+
+    except Exception as e:
+        logger.error("Model loading failed: %s", e, exc_info=True)
+        return False
+
+
+def _run_inference_on_dcm(dcm_path: Path) -> tuple[dict | None, dict | None]:
+    """
+    Run inference on one .dcm file, with blackbox tracing.
+    Returns (report_dict, trace_metadata) or (None, None) on failure.
+    """
+    if not _ensure_model_loaded():
+        return None, None
+
+    ri = _MODEL["inference_mod"]
+    image_id = dcm_path.stem
+
+    # Start tracing this inference run
+    bbr.start()
+
+    try:
+        img_rgb = ri.dicom_to_rgb(str(dcm_path), size=ri.IMG_SIZE)
+
+        inference = ri.infer_single(
+            img_rgb,
+            _MODEL["model"],
+            _MODEL["grad_cam"],
+            _MODEL["transform"],
+            _MODEL["device"],
+            _MODEL["temperature"],
+        )
+
+        REPORTS_DIR.mkdir(parents=True, exist_ok=True)
+        report = ri.build_report(
+            image_id, inference, _MODEL["calib_cfg"],
+            REPORTS_DIR, img_rgb, true_label=None,
+        )
+        pred = report.get("prediction", {})
+        pred.setdefault("raw_probability", inference.get("raw_prob_any"))
+        pred.setdefault("calibrated_probability", inference.get("cal_prob_any"))
+        pred.setdefault("decision_threshold", pred.get("decision_threshold_any"))
+        report["prediction"] = pred
+
+        report_path = REPORTS_DIR / f"{image_id}_report.json"
+        with open(report_path, "w") as f:
+            json.dump(report, f, indent=2)
+
+        _append_to_summary_csv(image_id, report)
+        _CACHE["data_signature"] = None
+
+    except Exception:
+        bbr.stop()
+        raise
+
+    # Stop tracing and save the execution log
+    bbr.stop()
+    trace_meta = _save_trace(image_id)
+
+    return report, trace_meta
+
+
+def _append_to_summary_csv(image_id: str, report: dict):
+    """Append one report row to the summary CSV."""
+    pred = report["prediction"]
+    row = {
+        "image_id":          image_id,
+        "true_label":        "",
+        "screening_outcome": pred["screening_outcome"],
+        "raw_prob":          pred["raw_probability"],
+        "cal_prob":          pred["calibrated_probability"],
+        "confidence_band":   pred["confidence_band"],
+        "triage_action":     report["triage"]["action"],
+        "urgency":           report["triage"]["urgency"],
+        "generated_at":      report.get("generated_at", ""),
+    }
+
+    file_exists = SUMMARY_CSV.exists()
+    OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
+    with open(SUMMARY_CSV, "a", newline="", encoding="utf-8") as f:
+        writer = csv.DictWriter(f, fieldnames=row.keys())
+        if not file_exists:
+            writer.writeheader()
+        writer.writerow(row)
+
+
+# ══════════════════════════════════════════════════════════════════════════
+#  DATA MODEL
+# ══════════════════════════════════════════════════════════════════════════
+
+@dataclass
+class CaseRow:
+    image_id:     str        = ""
+    outcome:      str        = "Unknown"
+    raw_prob:     float|None = None
+    cal_prob:     float|None = None
+    band:         str        = "N/A"
+    triage:       str        = "N/A"
+    urgency:      str        = "N/A"
+    true_label:   str        = ""
+    generated_at: str        = ""     # ISO timestamp from report JSON
+    report_file:  str|None   = None
+    gradcam_file: str|None   = None
+
+    @property
+    def date_display(self) -> str:
+        """Format the ISO timestamp as a short readable date."""
+        if not self.generated_at:
+            return "—"
+        try:
+            dt = datetime.datetime.fromisoformat(self.generated_at)
+            return dt.strftime("%Y-%m-%d %H:%M")
+        except (ValueError, TypeError):
+            return self.generated_at[:16]
+
+    @property
+    def is_positive(self) -> bool:
+        return "no hemorrhage" not in self.outcome.lower()
+
+
+# ══════════════════════════════════════════════════════════════════════════
+#  UTILITIES
+# ══════════════════════════════════════════════════════════════════════════
+
+def _to_float(value: Any) -> float | None:
+    try:
+        return float(value) if value not in (None, "") else None
+    except (TypeError, ValueError):
+        return None
+
+
+def _file_mtime(path: Path) -> int:
+    try:
+        return path.stat().st_mtime_ns if path.exists() else -1
+    except OSError:
+        return -1
+
+
+def _data_signature() -> tuple[int, int]:
+    return _file_mtime(REPORTS_DIR), _file_mtime(SUMMARY_CSV)
+
+
+def _parse_positive_int(value: str | None, default: int) -> int:
+    try:
+        n = int(value or default)
+        return n if n > 0 else default
+    except (TypeError, ValueError):
+        return default
+
+
+# ══════════════════════════════════════════════════════════════════════════
+#  DATA LOADING
+# ══════════════════════════════════════════════════════════════════════════
+
+def _load_summary_csv() -> dict[str, dict[str, Any]]:
+    """Read report_summary.csv into memory, keyed by image_id."""
+    if not SUMMARY_CSV.exists():
+        return {}
+    rows: dict[str, dict[str, Any]] = {}
+    with SUMMARY_CSV.open("r", encoding="utf-8") as f:
+        for row in csv.DictReader(f):
+            iid = (row.get("image_id") or "").strip()
+            if not iid:
+                continue
+            rows[iid] = {
+                "image_id":     iid,
+                "outcome":      row.get("screening_outcome", "Unknown"),
+                "raw_prob":     _to_float(row.get("raw_prob")),
+                "cal_prob":     _to_float(row.get("cal_prob")),
+                "band":         row.get("confidence_band") or "N/A",
+                "triage":       row.get("triage_action")   or "N/A",
+                "urgency":      row.get("urgency")         or "N/A",
+                "true_label":   row.get("true_label", ""),
+                "generated_at": row.get("generated_at", ""),
+            }
+    return rows
+
+
+def _scan_report_assets() -> tuple[set[str], set[str]]:
+    """One dir walk to find which image IDs have JSON and PNG files."""
+    report_ids:  set[str] = set()
+    gradcam_ids: set[str] = set()
+    if not REPORTS_DIR.exists():
+        return report_ids, gradcam_ids
+    for path in REPORTS_DIR.iterdir():
+        if not path.is_file():
+            continue
+        if path.name.endswith("_report.json"):
+            report_ids.add(path.name[:-12])
+        elif path.name.endswith("_gradcam.png"):
+            gradcam_ids.add(path.name[:-12])
+    return report_ids, gradcam_ids
+
+
+def _read_generated_at(image_id: str) -> str:
+    """Read the generated_at timestamp from a report JSON file."""
+    path = REPORTS_DIR / f"{image_id}_report.json"
+    if not path.exists():
+        return ""
+    try:
+        data = json.loads(path.read_text("utf-8"))
+        return data.get("generated_at", "")
+    except (json.JSONDecodeError, OSError):
+        return ""
+
+
+def _load_cases_from_json() -> dict[str, CaseRow]:
+    """Fallback: read each *_report.json when CSV is unavailable."""
+    summary = _load_summary_csv()
+    cases: dict[str, CaseRow] = {}
+    for rp in sorted(REPORTS_DIR.glob("*_report.json")):
+        try:
+            payload = json.loads(rp.read_text("utf-8"))
+        except (json.JSONDecodeError, OSError):
+            continue
+        iid  = str(payload.get("image_id", rp.stem.replace("_report", ""))).strip()
+        pred = payload.get("prediction", {})
+        tri  = payload.get("triage", {})
+        expl = payload.get("explainability", {})
+        sr   = summary.get(iid, {})
+        gc   = Path(str(expl.get("heatmap_path", ""))).name or None
+        cases[iid] = CaseRow(
+            image_id=iid,
+            outcome=pred.get("screening_outcome", sr.get("outcome", "Unknown")),
+            raw_prob=_to_float(pred.get("raw_probability", sr.get("raw_prob"))),
+            cal_prob=_to_float(pred.get("calibrated_probability", sr.get("cal_prob"))),
+            band=pred.get("confidence_band", sr.get("band", "N/A")),
+            triage=tri.get("action", sr.get("triage", "N/A")),
+            urgency=tri.get("urgency", sr.get("urgency", "N/A")),
+            true_label=str(payload.get("ground_truth_label", sr.get("true_label", ""))),
+            generated_at=payload.get("generated_at", ""),
+            report_file=rp.name,
+            gradcam_file=gc,
+        )
+    return cases
+
+
+def load_cases_cached() -> dict[str, CaseRow]:
+    """Return all cases, re-reading from disk only when files change."""
+    sig = _data_signature()
+    if _CACHE["data_signature"] == sig:
+        _CACHE["data_last_cache_hit"] = True
+        return _CACHE["cases"]
+
+    start   = time.perf_counter()
+    summary = _load_summary_csv()
+
+    if summary:
+        report_ids, gradcam_ids = _scan_report_assets()
+        cases = {}
+        for iid, sr in summary.items():
+            # Resolve generated_at: prefer CSV value, fall back to JSON file
+            gen_at = sr.get("generated_at", "")
+            if not gen_at and iid in report_ids:
+                gen_at = _read_generated_at(iid)
+
+            cases[iid] = CaseRow(
+                image_id=iid,
+                outcome=sr.get("outcome", "Unknown"),
+                raw_prob=_to_float(sr.get("raw_prob")),
+                cal_prob=_to_float(sr.get("cal_prob")),
+                band=sr.get("band", "N/A"),
+                triage=sr.get("triage", "N/A"),
+                urgency=sr.get("urgency", "N/A"),
+                true_label=sr.get("true_label", ""),
+                generated_at=gen_at,
+                report_file=f"{iid}_report.json" if iid in report_ids else None,
+                gradcam_file=f"{iid}_gradcam.png" if iid in gradcam_ids else None,
+            )
+    elif REPORTS_DIR.exists():
+        cases = _load_cases_from_json()
+    else:
+        cases = {}
+
+    elapsed_ms = (time.perf_counter() - start) * 1000
+    _CACHE.update({
+        "data_signature":       sig,
+        "cases":                cases,
+        "rows_sorted":          sorted(cases.values(), key=lambda c: c.image_id),
+        "data_last_refresh_ms": elapsed_ms,
+        "data_last_cache_hit":  False,
+    })
+    logger.info("Cache refresh: %d cases in %.1f ms", len(cases), elapsed_ms)
+    return cases
+
+
+def load_case_payload(image_id: str) -> dict[str, Any] | None:
+    """Load full JSON report for one case (Raw JSON button)."""
+    path = REPORTS_DIR / f"{image_id}_report.json"
+    if not path.exists():
+        return None
+    try:
+        return json.loads(path.read_text("utf-8"))
+    except (json.JSONDecodeError, OSError):
+        return None
+
+
+def compute_stats(rows: list[CaseRow]) -> dict[str, Any]:
+    """Compute summary statistics for the dashboard cards."""
+    total    = len(rows)
+    positive = sum(1 for r in rows if r.is_positive)
+    urgent   = sum(1 for r in rows if r.urgency.upper() == "URGENT")
+    heatmaps = sum(1 for r in rows if r.gradcam_file)
+    cal_probs = [r.cal_prob for r in rows if r.cal_prob is not None]
+    avg_cal   = sum(cal_probs) / len(cal_probs) if cal_probs else 0.0
+    pos_rate  = (positive / total * 100) if total else 0.0
+
+    # Date range
+    dates = sorted(r.generated_at for r in rows if r.generated_at)
+    newest = dates[-1] if dates else ""
+    oldest = dates[0]  if dates else ""
+
+    return {
+        "total":          total,
+        "positive":       positive,
+        "negative":       total - positive,
+        "urgent":         urgent,
+        "heatmaps":       heatmaps,
+        "avg_cal_prob":   avg_cal,
+        "pos_rate":       pos_rate,
+        "band_counts":    dict(Counter(r.band.upper()    for r in rows)),
+        "urgency_counts": dict(Counter(r.urgency.upper() for r in rows)),
+        "newest_date":    newest,
+        "oldest_date":    oldest,
+    }
+
+
+def _load_json_cached(path: Path, sig_key: str, data_key: str, label: str) -> dict[str, Any]:
+    """Mtime-based JSON cache loader for calibration/normalization."""
+    sig = _file_mtime(path)
+    if _CACHE[sig_key] == sig:
+        return _CACHE[data_key]
+    data: dict[str, Any] = {}
+    if path.exists():
+        try:
+            data = json.loads(path.read_text("utf-8"))
+        except (json.JSONDecodeError, OSError):
+            logger.warning("Could not read %s", path)
+    _CACHE[sig_key] = sig
+    _CACHE[data_key] = data
+    return data
+
+
+def load_calibration() -> dict[str, Any]:
+    calib = _load_json_cached(CALIB_JSON, "calib_signature", "calib", "Calibration")
+    if not calib:
+        return {}
+    # Backward-compatible aliases expected by templates.
+    return {
+        **calib,
+        "method": calib.get("method", calib.get("best_method", "N/A")),
+        "temperature": calib.get("temperature", 1.0),
+        "raw_ece": calib.get("ece_raw", 0.0),
+        "cal_ece": calib.get("ece_isotonic", calib.get("ece_temp", 0.0)),
+        "raw_brier": calib.get("brier_raw", 0.0),
+        "cal_brier": calib.get("brier_isotonic", calib.get("brier_temp", 0.0)),
+        "calibrated_threshold": calib.get("threshold_at_spec90", 0.5),
+        "base_threshold": calib.get("base_threshold", 0.5),
+        "high_threshold": calib.get("high_threshold", calib.get("triage_high_thresh", 0.7)),
+        "low_threshold": calib.get("low_threshold", calib.get("triage_low_thresh", 0.3)),
+    }
+
+
+def load_normalization() -> dict[str, Any]:
+    return _load_json_cached(NORM_JSON, "norm_signature", "norm", "Normalization")
+
+
+def filter_cases(
+    rows: list[CaseRow],
+    q: str,
+    band: str,
+    urgency: str,
+    outcome: str,
+    sort_by: str,
+) -> list[CaseRow]:
+    """Apply text search, dropdown filters, and sorting."""
+    if q:
+        ql = q.lower()
+        rows = [r for r in rows if ql in r.image_id.lower() or ql in r.outcome.lower()]
+    if band:
+        rows = [r for r in rows if r.band.upper() == band.upper()]
+    if urgency:
+        rows = [r for r in rows if r.urgency.upper() == urgency.upper()]
+    if outcome == "POSITIVE":
+        rows = [r for r in rows if r.is_positive]
+    elif outcome == "NEGATIVE":
+        rows = [r for r in rows if not r.is_positive]
+
+    if sort_by == "date_desc":
+        rows = sorted(rows, key=lambda r: r.generated_at or "", reverse=True)
+    elif sort_by == "date_asc":
+        rows = sorted(rows, key=lambda r: r.generated_at or "")
+    elif sort_by == "prob_desc":
+        rows = sorted(rows, key=lambda r: r.cal_prob or 0, reverse=True)
+    elif sort_by == "prob_asc":
+        rows = sorted(rows, key=lambda r: r.cal_prob or 0)
+    # default: sorted by image_id (already the case from cache)
+
+    return rows
+
+
+def load_logs() -> list[dict]:
+    """Scan the logs/ directory and return metadata for each trace."""
+    if not LOGS_DIR.exists():
+        return []
+
+    log_files: dict[str, dict] = {}  # base_name -> {txt_file, json_file, ...}
+
+    for path in sorted(LOGS_DIR.iterdir(), reverse=True):
+        if not path.is_file():
+            continue
+        stem = path.stem  # e.g. "20260228_153000_ID_abc123"
+        if path.suffix == ".txt":
+            log_files.setdefault(stem, {})["txt_file"] = path.name
+            # Parse out timestamp and image_id from filename
+            parts = stem.split("_", 2)
+            if len(parts) >= 3:
+                log_files[stem]["timestamp"] = f"{parts[0]}_{parts[1]}"
+                log_files[stem]["image_id"]  = parts[2]
+            log_files[stem]["size_kb"] = round(path.stat().st_size / 1024, 1)
+        elif path.suffix == ".json":
+            log_files.setdefault(stem, {})["json_file"] = path.name
+
+    entries = []
+    for stem in sorted(log_files, reverse=True):
+        info = log_files[stem]
+        ts_raw = info.get("timestamp", "")
+        try:
+            dt = datetime.datetime.strptime(ts_raw, "%Y%m%d_%H%M%S")
+            display = dt.strftime("%Y-%m-%d %H:%M:%S")
+        except ValueError:
+            display = ts_raw
+        entries.append({
+            "stem":      stem,
+            "timestamp": display,
+            "image_id":  info.get("image_id", ""),
+            "txt_file":  info.get("txt_file"),
+            "json_file": info.get("json_file"),
+            "size_kb":   info.get("size_kb", 0),
+        })
+
+    return entries
+
+
+# ═══════════════════���══════════════════════════════════════════════════════
+#  MIDDLEWARE
+# ══════════════════════════════════════════════════════════════════════════
+
+@app.before_request
+def _start_timer():
+    g._start_time = time.perf_counter()
+
+
+@app.after_request
+def _log_timing(response):
+    elapsed = (time.perf_counter() - getattr(g, "_start_time", time.perf_counter())) * 1000
+    logger.info("%s %s -> %s (%.1f ms)", request.method, request.path, response.status_code, elapsed)
+    return response
+
+
+# ══════════════════════════════════════════════════════════════════════════
+#  ROUTES
+# ══════════════════════════════════════════════════════════════════════════
+
+@app.route("/")
+def home():
+    """Landing page with quick stats and navigation."""
+    load_cases_cached()
+    all_rows = _CACHE["rows_sorted"]
+    stats = compute_stats(all_rows)
+    log_count = len(list(LOGS_DIR.glob("*.txt"))) if LOGS_DIR.exists() else 0
+    return render_template("home.html", stats=stats, log_count=log_count)
+
+
+@app.route("/upload")
+def upload():
+    return render_template("upload.html", local_mode=LOCAL_MODE)
+
+
+@app.route("/analyze", methods=["POST"])
+def analyze():
+    """
+    Accept one or more .dcm files (or a .zip) and run inference.
+
+    Single file  → synchronous, redirect straight to the report.
+    Multiple     → asynchronous batch, redirect to progress page.
+    """
+    files = request.files.getlist("file")
+    files = [f for f in files if f.filename]
+
+    if not files:
+        flash("No files were uploaded.", "error")
+        return redirect(url_for("upload"))
+
+    UPLOAD_DIR.mkdir(parents=True, exist_ok=True)
+
+    # ── Collect all .dcm paths (expand .zip archives) ────────────────
+    dcm_paths: list[Path] = []
+    temp_dir: str | None = None      # set if a zip needed extraction
+
+    for f in files:
+        fname = f.filename.lower()
+
+        if fname.endswith(".zip"):
+            temp_dir = tempfile.mkdtemp(prefix="ich_zip_")
+            zip_save = Path(temp_dir) / secure_filename(f.filename)
+            f.save(str(zip_save))
+            try:
+                with zipfile.ZipFile(zip_save, "r") as zf:
+                    zf.extractall(temp_dir)
+            except zipfile.BadZipFile:
+                shutil.rmtree(temp_dir, ignore_errors=True)
+                flash("The uploaded ZIP file is corrupted.", "error")
+                return redirect(url_for("upload"))
+            # Recursively find .dcm inside extracted tree
+            dcm_paths.extend(sorted(Path(temp_dir).rglob("*.dcm")))
+
+        elif fname.endswith(".dcm"):
+            safe = secure_filename(f.filename)
+            save_path = UPLOAD_DIR / safe
+            f.save(str(save_path))
+            dcm_paths.append(save_path)
+
+        else:
+            # skip non-dcm / non-zip silently
+            continue
+
+    if not dcm_paths:
+        flash("No .dcm files found in the upload.", "error")
+        if temp_dir:
+            shutil.rmtree(temp_dir, ignore_errors=True)
+        return redirect(url_for("upload"))
+
+    # ── Single file → synchronous (fast path) ────────────────────────
+    if len(dcm_paths) == 1 and temp_dir is None:
+        single_path = dcm_paths[0]
+        try:
+            report, trace = _run_inference_on_dcm(single_path)
+            if report is None:
+                flash("Model failed to load. Check server logs.", "error")
+                return redirect(url_for("upload"))
+            return redirect(url_for("case_detail", image_id=single_path.stem))
+        except Exception as e:
+            logger.error("Analysis failed for %s: %s", single_path.name, e, exc_info=True)
+            flash(f"Analysis failed: {e}", "error")
+            return redirect(url_for("upload"))
+        finally:
+            if single_path.exists() and single_path.parent == UPLOAD_DIR:
+                single_path.unlink()
+
+    # ── Multiple files → asynchronous batch ──────────────────────────
+    batch_id = _start_batch(dcm_paths, temp_dir=temp_dir)
+    logger.info("Batch %s started: %d files", batch_id, len(dcm_paths))
+    return redirect(url_for("batch_progress", batch_id=batch_id))
+
+
+@app.route("/analyze/directory", methods=["POST"])
+def analyze_directory():
+    """
+    Local-only route: scan a server-side directory for .dcm files and
+    start a batch job.  Disabled when LOCAL_MODE is off.
+    """
+    if not LOCAL_MODE:
+        abort(403)
+
+    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"))
+
+    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"))
+    if not dcm_paths:
+        flash(f"No .dcm files found in: {dir_path_str}", "error")
+        return redirect(url_for("upload"))
+
+    batch_id = _start_batch(dcm_paths)
+    logger.info("Directory batch %s started: %d files from %s", batch_id, len(dcm_paths), dir_path_str)
+    return redirect(url_for("batch_progress", batch_id=batch_id))
+
+
+@app.route("/batch/progress/<batch_id>")
+def batch_progress(batch_id: str):
+    """Batch progress page — polls /batch/status/<id> via JS."""
+    with _BATCHES_LOCK:
+        batch = _BATCHES.get(batch_id)
+    if not batch:
+        abort(404)
+    return render_template("batch_progress.html", batch_id=batch_id, batch=batch)
+
+
+@app.route("/batch/status/<batch_id>")
+def batch_status(batch_id: str):
+    """JSON endpoint polled by the progress page for live updates."""
+    with _BATCHES_LOCK:
+        batch = _BATCHES.get(batch_id)
+    if not batch:
+        return jsonify({"error": "not found"}), 404
+    # Return a safe copy (no Path objects)
+    return jsonify({
+        "status":       batch["status"],
+        "total":        batch["total"],
+        "processed":    batch["processed"],
+        "succeeded":    batch["succeeded"],
+        "failed_count": len(batch["failed_ids"]),
+        "failed_ids":   batch["failed_ids"][:20],   # cap for payload size
+        "current_file": batch["current_file"],
+        "image_ids":    batch["image_ids"][-5:],     # last 5 for display
+        "started_at":   batch["started_at"],
+        "finished_at":  batch["finished_at"],
+    })
+
+
+@app.route("/reports")
+def reports():
+    """Past reports page with filtering, sorting, and pagination."""
+    route_start = time.perf_counter()
+
+    load_cases_cached()
+    all_rows = _CACHE["rows_sorted"]
+
+    # Read all filter/sort/pagination params from query string
+    q         = request.args.get("q", "").strip()
+    band      = request.args.get("band", "").strip()
+    urgency   = request.args.get("urgency", "").strip()
+    outcome   = request.args.get("outcome", "").strip()
+    sort_by   = request.args.get("sort", "").strip()
+    page      = _parse_positive_int(request.args.get("page"), 1)
+    page_size = _parse_positive_int(request.args.get("page_size"), 50)
+    if page_size not in (10, 50, 100):
+        page_size = 50
+
+    filtered    = filter_cases(all_rows, q, band, urgency, outcome, sort_by)
+    stats       = compute_stats(filtered)
+    total       = len(filtered)
+    total_pages = max(1, math.ceil(total / page_size))
+    page        = min(page, total_pages)
+    start_idx   = (page - 1) * page_size
+    rows        = filtered[start_idx: start_idx + page_size]
+    route_ms    = (time.perf_counter() - route_start) * 1000
+
+    return render_template(
+        "reports.html",
+        rows=rows,
+        stats=stats,
+        calib=load_calibration(),
+        q=q, band=band, urgency=urgency, outcome=outcome, sort=sort_by,
+        page=page,
+        page_size=page_size,
+        page_start=start_idx,
+        total_pages=total_pages,
+        total_items=total,
+        total_cases=len(all_rows),
+        route_compute_ms=route_ms,
+        data_refresh_ms=_CACHE["data_last_refresh_ms"],
+        data_cache_hit=_CACHE["data_last_cache_hit"],
+    )
+
+
+@app.route("/case/<image_id>")
+def case_detail(image_id: str):
+    """Individual case report page."""
+    cases = load_cases_cached()
+    row = cases.get(image_id)
+    if not row:
+        abort(404)
+    payload = load_case_payload(image_id)
+    return render_template("detail.html", row=row, payload=payload)
+
+
+@app.route("/logs")
+def logs_page():
+    """Execution logs page."""
+    entries = load_logs()
+    return render_template("logs.html", logs=entries)
+
+
+@app.route("/logs/view/<path:filename>")
+def serve_log(filename: str):
+    """Serve a log file (txt or json) for viewing."""
+    if not LOGS_DIR.exists():
+        abort(404)
+    return send_from_directory(LOGS_DIR, filename)
+
+
+@app.route("/evaluation")
+def evaluation():
+    load_cases_cached()
+    all_rows = _CACHE["rows_sorted"]
+
+    cal_probs = [r.cal_prob for r in all_rows if r.cal_prob is not None]
+    bins = [0] * 10
+    for p in cal_probs:
+        bins[min(int(p * 10), 9)] += 1
+
+    band_data = {}
+    for bnd in ("HIGH", "MEDIUM", "LOW"):
+        subset   = [r for r in all_rows if r.band.upper() == bnd]
+        positive = sum(1 for r in subset if r.is_positive)
+        band_data[bnd] = {
+            "total":    len(subset),
+            "positive": positive,
+            "negative": len(subset) - positive,
+        }
+
+    return render_template(
+        "evaluation.html",
+        stats=compute_stats(all_rows),
+        calib=load_calibration(),
+        norm=load_normalization(),
+        bins=bins,
+        band_data=band_data,
+        total=len(all_rows),
+    )
+
+
+@app.route("/about")
+def about():
+    return render_template("about.html", calib=load_calibration())
+
+
+@app.route("/gradcam/<path:filename>")
+def serve_gradcam(filename: str):
+    if not REPORTS_DIR.exists():
+        abort(404)
+    return send_from_directory(REPORTS_DIR, filename)
+
+
+@app.route("/report-json/<path:filename>")
+def serve_report_json(filename: str):
+    if not REPORTS_DIR.exists():
+        abort(404)
+    return send_from_directory(REPORTS_DIR, filename)
+
+
+# ══════════════════════════════════════════════════════════════════════════
+#  ENTRY POINT
+# ══════════════════════════════════════════════════════════════════════════
+
+if __name__ == "__main__":
+    print("=" * 60)
+    print("  ICH Screening Web Application")
+    print(f"  Data  ->  {OUTPUT_DIR}")
+    print(f"  Logs  ->  {LOGS_DIR}")
+    print(f"  Open  ->  http://127.0.0.1:{APP_PORT}")
+    print("=" * 60)
+    app.run(debug=APP_DEBUG, port=APP_PORT)

requirements.txt

@@ -0,0 +1,16 @@
+flask
+werkzeug
+
+numpy
+pandas
+opencv-python
+pydicom
+
+torch
+timm
+scikit-learn
+
+blackbox-recorder
+python-dotenv
+
+

run_interface.py

@@ -0,0 +1,182 @@
+"""Compatibility adapter for the web app inference API.
+
+This module bridges the Flask app's expected interface to the improved
+inference utilities in download_imp/run_inference.py.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+import cv2
+import numpy as np
+import torch
+
+from download_imp import run_inference as core
+
+ARCH = core.BACKBONE
+IMG_SIZE = core.IMG_SIZE
+SUBTYPES = core.SUBTYPES
+
+
+def _parse_fold_selection(value: str | None) -> str | int:
+    """Parse fold selection from env-style values.
+
+    Accepted values: "ensemble", "best", or an integer fold id.
+    """
+    raw = (value or "ensemble").strip().lower()
+    if raw in ("", "ensemble", "all"):
+        return "ensemble"
+    if raw == "best":
+        # From B4 performance report per-fold any-AUC table.
+        return 4
+    if raw.isdigit():
+        return int(raw)
+    return "ensemble"
+
+
+class _Compose:
+    def __init__(self, transforms: list[Any]):
+        self.transforms = transforms
+
+    def __call__(self, x: np.ndarray) -> torch.Tensor:
+        out = x
+        for t in self.transforms:
+            out = t(out)
+        return out
+
+
+class _ToPILImage:
+    def __call__(self, x: np.ndarray) -> np.ndarray:
+        # The web app pipeline does not require PIL specifically.
+        return x
+
+
+class _ToTensor:
+    def __call__(self, x: np.ndarray) -> torch.Tensor:
+        arr = np.asarray(x, dtype=np.float32)
+        if arr.ndim != 3:
+            raise ValueError("Expected HWC image array")
+        # Convert HWC -> CHW
+        return torch.from_numpy(np.transpose(arr, (2, 0, 1)))
+
+
+class _Normalize:
+    def __init__(self, mean: list[float], std: list[float]):
+        self.mean = torch.tensor(mean, dtype=torch.float32).view(-1, 1, 1)
+        self.std = torch.tensor(std, dtype=torch.float32).view(-1, 1, 1)
+
+    def __call__(self, x: torch.Tensor) -> torch.Tensor:
+        return (x - self.mean) / (self.std + 1e-7)
+
+
+class T:
+    Compose = _Compose
+    ToPILImage = _ToPILImage
+    ToTensor = _ToTensor
+    Normalize = _Normalize
+
+
+def build_model(_arch: str | None = None):
+    return core.build_model()
+
+
+def load_runtime_models(device: str, fold_selection: str | None = None):
+    """Load one or many fold models for web inference."""
+    parsed = _parse_fold_selection(fold_selection)
+    models, loaded_folds = core.load_models(device, fold_selection=parsed)
+    grad_cams = [GradCAM(m) for m in models]
+    return models, grad_cams, loaded_folds
+
+
+class GradCAM(core.GradCAM):
+    def __init__(self, model, _arch: str | None = None):
+        super().__init__(model)
+
+
+def dicom_to_rgb(dcm_path: str, size: int = IMG_SIZE) -> np.ndarray:
+    return core.load_single_dicom_3ch(Path(dcm_path), size=size)
+
+
+def infer_single(
+    img_rgb: np.ndarray,
+    model,
+    grad_cam: GradCAM,
+    transform,
+    device: str,
+    temperature: float,
+) -> dict[str, Any]:
+    # Build 3ch tensor from the app's transform pipeline, then tile to 9ch
+    # because the trained model expects 2.5D channels.
+    t3 = transform(img_rgb).unsqueeze(0).to(device)
+    t9 = torch.cat([t3, t3, t3], dim=1)
+
+    if isinstance(model, list) and isinstance(grad_cam, list):
+        fold_logits = []
+        fold_cams = []
+        for _m, cam_obj in zip(model, grad_cam):
+            logits_i, cam_i = cam_obj.generate(t9, class_idx=0)
+            fold_logits.append(logits_i)
+            fold_cams.append(cam_i)
+        logits = np.mean(np.stack(fold_logits, axis=0), axis=0)
+        cam = np.mean(np.stack(fold_cams, axis=0), axis=0)
+    else:
+        logits, cam = grad_cam.generate(t9, class_idx=0)
+
+    raw_probs = core.sigmoid_np(logits)
+    cal_probs = core.sigmoid_np(logits / max(float(temperature), 1e-6))
+
+    return {
+        "raw_logits": logits,
+        "raw_probs": raw_probs,
+        "cal_probs": cal_probs,
+        "raw_prob_any": float(raw_probs[0]),
+        "cal_prob_any": float(cal_probs[0]),
+        "cam": cam,
+    }
+
+
+def build_report(
+    image_id: str,
+    inference: dict[str, Any],
+    calib_cfg: dict[str, Any],
+    reports_dir: Path,
+    img_rgb: np.ndarray,
+    true_label: int | None = None,
+) -> dict[str, Any]:
+    reports_dir.mkdir(parents=True, exist_ok=True)
+
+    preview_path = reports_dir / f"{image_id}_preview.png"
+    heatmap_path = reports_dir / f"{image_id}_gradcam.png"
+
+    rgb_u8 = (np.clip(img_rgb, 0.0, 1.0) * 255.0).astype(np.uint8)
+    cv2.imwrite(str(preview_path), cv2.cvtColor(rgb_u8, cv2.COLOR_RGB2BGR))
+
+    overlay_rgb = core.make_overlay(rgb_u8, inference["cam"], alpha=0.45)
+    cv2.imwrite(str(heatmap_path), cv2.cvtColor(overlay_rgb, cv2.COLOR_RGB2BGR))
+
+    probs_dict = {
+        name: float(inference["cal_probs"][idx])
+        for idx, name in enumerate(SUBTYPES)
+    }
+    threshold = float(calib_cfg.get("threshold_at_spec90", 0.5))
+
+    report = core.build_slice_report(
+        image_id=image_id,
+        patient_id="UNKNOWN",
+        probs=probs_dict,
+        calib_cfg=calib_cfg,
+        threshold=threshold,
+        loaded_folds=[0],
+        report_image_path=str(preview_path),
+        heatmap_path=str(heatmap_path),
+        true_label=true_label,
+    )
+
+    report.setdefault("prediction", {})
+    report["prediction"]["decision_threshold"] = report["prediction"].get("decision_threshold_any", threshold)
+    report["prediction"]["raw_probability"] = round(float(inference["raw_prob_any"]), 6)
+    report["prediction"]["calibrated_probability"] = round(float(inference["cal_prob_any"]), 6)
+
+    return report

static/styles.css

@@ -0,0 +1,1291 @@
+/* ═══════════════════════════════════════════════════════════════
+   ICH Screening Dashboard — Stylesheet
+   ═══════════════════════════════════════════════════════════════ */
+
+:root {
+  --bg: #070d1a;
+  --bg2: #0c1427;
+  --panel: #111c33;
+  --panel2: #162244;
+  --surface: #1a2850;
+  --text: #e8ecf6;
+  --muted: #8ba0c4;
+  --line: #243356;
+  --accent: #6ea8fe;
+  --green: #34d399;
+  --red: #fb7185;
+  --orange: #fbbf24;
+  --blue: #60a5fa;
+  --radius: 14px;
+}
+
+/* ── Reset ─────────────────────────────────────────────────── */
+*,
+*::before,
+*::after {
+  box-sizing: border-box;
+  margin: 0;
+  padding: 0;
+}
+html {
+  scroll-behavior: smooth;
+}
+body {
+  font-family:
+    "Inter",
+    system-ui,
+    -apple-system,
+    "Segoe UI",
+    Roboto,
+    sans-serif;
+  background:
+    radial-gradient(
+      ellipse 1400px 500px at 5% -5%,
+      #1a2f55 0%,
+      transparent 60%
+    ),
+    radial-gradient(
+      ellipse 1200px 500px at 95% -5%,
+      #2a1d46 0%,
+      transparent 55%
+    ),
+    var(--bg);
+  color: var(--text);
+  line-height: 1.6;
+  min-height: 100vh;
+}
+
+/* ── Layout ────────────────────────────────────────────────── */
+.container {
+  width: min(1240px, 94vw);
+  margin: 0 auto;
+}
+.page {
+  padding: 20px 0 48px;
+}
+
+/* ── Topbar ────────────────────────────────────────────────── */
+.topbar {
+  position: sticky;
+  top: 0;
+  z-index: 50;
+  background: rgba(7, 13, 26, 0.88);
+  backdrop-filter: blur(12px);
+  border-bottom: 1px solid var(--line);
+}
+.topbar-inner {
+  display: flex;
+  align-items: center;
+  justify-content: space-between;
+  width: 100%;
+  padding: 14px 24px;
+}
+.brand {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  font-weight: 800;
+  font-size: 1.05rem;
+  color: var(--text);
+  text-decoration: none;
+}
+.brand-icon {
+  color: var(--accent);
+  display: flex;
+}
+.nav-links {
+  display: flex;
+  gap: 6px;
+}
+.nav-links a {
+  padding: 6px 14px;
+  border-radius: 8px;
+  color: var(--muted);
+  text-decoration: none;
+  font-weight: 500;
+  font-size: 0.9rem;
+  transition: all 0.15s;
+}
+.nav-links a:hover {
+  color: var(--text);
+  background: var(--panel);
+}
+.nav-links a.active {
+  color: var(--accent);
+  background: rgba(110, 168, 254, 0.1);
+}
+
+/* ── Hero ──────────────────────────────────────────────────── */
+.hero {
+  padding: 8px 0 6px;
+}
+.hero h1 {
+  font-size: 1.8rem;
+  font-weight: 800;
+}
+.hero p {
+  color: var(--muted);
+  margin-top: 6px;
+}
+
+/* ── Stats row ─────────────────────────────────────────────── */
+.stats-row {
+  display: grid;
+  grid-template-columns: repeat(6, 1fr);
+  gap: 12px;
+  margin: 16px 0;
+}
+.stat-card {
+  background: linear-gradient(180deg, var(--panel2), var(--panel));
+  border: 1px solid var(--line);
+  border-radius: var(--radius);
+  padding: 16px;
+}
+.stat-label {
+  font-size: 0.82rem;
+  color: var(--muted);
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+}
+.stat-value {
+  font-size: 1.6rem;
+  font-weight: 800;
+  margin-top: 4px;
+}
+.stat-card.accent-green .stat-value {
+  color: var(--green);
+}
+.stat-card.accent-red .stat-value {
+  color: var(--red);
+}
+.stat-card.accent-orange .stat-value {
+  color: var(--orange);
+}
+.stat-card.accent-blue .stat-value {
+  color: var(--blue);
+}
+
+/* ── Info bar ──────────────────────────────────────────────── */
+.info-bar {
+  display: flex;
+  gap: 24px;
+  flex-wrap: wrap;
+  padding: 10px 16px;
+  border-radius: 10px;
+  background: var(--panel);
+  border: 1px solid var(--line);
+  font-size: 0.88rem;
+  color: var(--muted);
+  margin-bottom: 12px;
+}
+.info-bar strong {
+  color: var(--text);
+}
+
+/* ── Panel ─────────────────────────────────────────────────── */
+.panel {
+  background: linear-gradient(180deg, var(--panel2), var(--panel));
+  border: 1px solid var(--line);
+  border-radius: var(--radius);
+  padding: 20px;
+  margin-top: 16px;
+}
+.panel h3 {
+  font-size: 1rem;
+  font-weight: 700;
+  margin-bottom: 12px;
+}
+
+/* ── Filters ───────────────────────────────────────────────── */
+.filters {
+  display: flex;
+  gap: 10px;
+  flex-wrap: wrap;
+  margin-bottom: 14px;
+}
+.filters input,
+.filters select {
+  flex: 1;
+  min-width: 140px;
+}
+input,
+select {
+  background: var(--bg2);
+  color: var(--text);
+  border: 1px solid var(--line);
+  border-radius: 10px;
+  padding: 10px 12px;
+  font-size: 0.9rem;
+  font-family: inherit;
+  transition: border-color 0.15s;
+}
+input:focus,
+select:focus {
+  outline: none;
+  border-color: var(--accent);
+}
+
+/* ── Buttons ───────────────────────────────────────────────── */
+.btn,
+button {
+  display: inline-flex;
+  align-items: center;
+  gap: 6px;
+  padding: 8px 16px;
+  border-radius: 10px;
+  border: 1px solid var(--line);
+  background: var(--panel);
+  color: var(--text);
+  font-size: 0.88rem;
+  font-weight: 500;
+  font-family: inherit;
+  cursor: pointer;
+  text-decoration: none;
+  transition: all 0.15s;
+}
+.btn:hover,
+button:hover {
+  border-color: var(--accent);
+  background: var(--surface);
+}
+.btn-sm {
+  padding: 5px 12px;
+  font-size: 0.82rem;
+}
+.btn-ghost {
+  background: transparent;
+}
+.btn-outline {
+  background: transparent;
+  border-color: var(--line);
+  color: var(--muted);
+}
+.btn-outline:hover {
+  border-color: var(--accent);
+  color: var(--accent);
+}
+
+/* ── Table ─────────────────────────────────────────────────── */
+.table-wrap {
+  overflow-x: auto;
+}
+table {
+  width: 100%;
+  border-collapse: collapse;
+  min-width: 940px;
+}
+th,
+td {
+  padding: 10px 12px;
+  border-bottom: 1px solid var(--line);
+  text-align: left;
+}
+th {
+  color: var(--muted);
+  font-weight: 600;
+  font-size: 0.82rem;
+  text-transform: uppercase;
+  letter-spacing: 0.03em;
+}
+tr.row-positive {
+  background: rgba(251, 113, 133, 0.04);
+}
+a {
+  color: var(--accent);
+  transition: color 0.15s;
+}
+a:hover {
+  color: #9ec5ff;
+}
+
+.link-icon {
+  display: inline-flex;
+}
+
+/* ── Badges ────────────────────────────────────────────────── */
+.badge {
+  display: inline-block;
+  padding: 3px 10px;
+  border-radius: 999px;
+  font-size: 0.78rem;
+  font-weight: 600;
+  letter-spacing: 0.03em;
+  border: 1px solid var(--line);
+  background: rgba(255, 255, 255, 0.04);
+}
+.badge-high {
+  border-color: #3b82f6;
+  color: #93bbfd;
+}
+.badge-medium {
+  border-color: #f59e0b;
+  color: #fcd34d;
+}
+.badge-low {
+  border-color: #6b7280;
+  color: #9ca3af;
+}
+.badge-urgent {
+  border-color: #ef4444;
+  color: #fca5a5;
+  background: rgba(239, 68, 68, 0.08);
+}
+.badge-standard {
+  border-color: #22c55e;
+  color: #86efac;
+}
+
+/* ── Dots ──────────────────────────────────────────────────── */
+.dot {
+  display: inline-block;
+  width: 8px;
+  height: 8px;
+  border-radius: 50%;
+  margin-right: 6px;
+  vertical-align: middle;
+}
+.dot-green {
+  background: var(--green);
+  box-shadow: 0 0 8px var(--green);
+}
+.dot-red {
+  background: var(--red);
+  box-shadow: 0 0 8px var(--red);
+}
+
+/* ── Utility ───────────────────────────────────────────────── */
+.mono {
+  font-family: "Consolas", "SF Mono", "Fira Code", monospace;
+}
+.muted {
+  color: var(--muted);
+}
+.small {
+  font-size: 0.85rem;
+}
+
+/* ── Detail page ───────────────────────────────────────────── */
+.breadcrumb {
+  padding: 8px 0;
+  font-size: 0.88rem;
+  color: var(--muted);
+}
+.breadcrumb a {
+  color: var(--accent);
+  text-decoration: none;
+}
+.sep {
+  margin: 0 8px;
+  opacity: 0.4;
+}
+
+.detail-header {
+  display: flex;
+  justify-content: space-between;
+  align-items: flex-start;
+  gap: 16px;
+  flex-wrap: wrap;
+  margin: 6px 0 10px;
+}
+.detail-header h1 {
+  font-size: 1.5rem;
+}
+.detail-actions {
+  display: flex;
+  gap: 8px;
+}
+
+.detail-grid {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 16px;
+  margin-top: 8px;
+}
+
+.kv-group {
+}
+.kv {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 9px 0;
+  border-bottom: 1px solid rgba(36, 51, 86, 0.6);
+  font-size: 0.92rem;
+  gap: 12px;
+}
+.kv span {
+  color: var(--muted);
+}
+
+.heatmap-img {
+  width: 100%;
+  border-radius: 12px;
+  border: 1px solid var(--line);
+}
+
+.empty-state {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  padding: 48px 16px;
+  gap: 12px;
+}
+
+/* Probability bar */
+.prob-bar-wrap {
+  margin-top: 20px;
+}
+.prob-bar-label {
+  display: flex;
+  justify-content: space-between;
+  font-size: 0.78rem;
+  color: var(--muted);
+  margin-bottom: 4px;
+}
+.prob-bar {
+  position: relative;
+  height: 24px;
+  border-radius: 12px;
+  background: var(--bg2);
+  border: 1px solid var(--line);
+  overflow: visible;
+}
+.prob-fill {
+  height: 100%;
+  border-radius: 12px;
+  transition: width 0.4s;
+}
+.fill-high {
+  background: linear-gradient(90deg, #3b82f6, #6366f1);
+}
+.fill-medium {
+  background: linear-gradient(90deg, #f59e0b, #f97316);
+}
+.fill-low {
+  background: linear-gradient(90deg, #6b7280, #9ca3af);
+}
+.prob-marker {
+  position: absolute;
+  top: -22px;
+  transform: translateX(-50%);
+  font-size: 0.76rem;
+  font-weight: 700;
+  color: var(--text);
+}
+
+.json-pre {
+  background: #080e1d;
+  border: 1px solid var(--line);
+  border-radius: 12px;
+  padding: 16px;
+  overflow: auto;
+  max-height: 500px;
+  font-size: 0.82rem;
+  line-height: 1.5;
+}
+
+/* Disclaimer */
+.disclaimer-box {
+  margin-top: 16px;
+  padding: 16px 20px;
+  border-radius: var(--radius);
+  background: rgba(251, 191, 36, 0.06);
+  border: 1px solid rgba(251, 191, 36, 0.2);
+  font-size: 0.9rem;
+  line-height: 1.6;
+  color: var(--muted);
+}
+.disclaimer-box strong {
+  color: var(--orange);
+}
+
+/* ── Evaluation page ───────────────────────────────────────── */
+.eval-grid {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 16px;
+  margin-top: 16px;
+}
+
+.metric-grid {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 10px;
+}
+.metric-card {
+  background: var(--bg2);
+  border: 1px solid var(--line);
+  border-radius: 10px;
+  padding: 14px;
+  text-align: center;
+}
+.metric-label {
+  font-size: 0.78rem;
+  color: var(--muted);
+  font-weight: 600;
+  text-transform: uppercase;
+}
+.metric-value {
+  font-size: 1.3rem;
+  font-weight: 800;
+  margin-top: 2px;
+  color: var(--accent);
+}
+
+/* Band analysis */
+.band-grid {
+  display: grid;
+  grid-template-columns: repeat(3, 1fr);
+  gap: 12px;
+  margin-top: 12px;
+}
+.band-card {
+  background: var(--bg2);
+  border: 1px solid var(--line);
+  border-radius: 12px;
+  padding: 14px;
+}
+.band-header {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  margin-bottom: 12px;
+}
+.band-total {
+  color: var(--muted);
+  font-size: 0.85rem;
+}
+.band-bar-row {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  margin-bottom: 6px;
+}
+.band-bar-label {
+  width: 60px;
+  font-size: 0.8rem;
+  color: var(--muted);
+}
+.band-bar {
+  flex: 1;
+  height: 14px;
+  border-radius: 7px;
+  background: var(--panel);
+  overflow: hidden;
+}
+.band-bar-fill {
+  height: 100%;
+  border-radius: 7px;
+  transition: width 0.4s;
+}
+.fill-red {
+  background: var(--red);
+}
+.fill-green {
+  background: var(--green);
+}
+.band-bar-val {
+  width: 36px;
+  font-size: 0.82rem;
+  text-align: right;
+}
+
+/* Histogram */
+.histogram {
+  display: flex;
+  align-items: flex-end;
+  gap: 6px;
+  margin-top: 12px;
+  padding: 8px 0;
+  min-height: 220px;
+}
+.hist-col {
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+}
+.hist-bar {
+  width: 100%;
+  border-radius: 6px 6px 0 0;
+  background: linear-gradient(180deg, var(--accent), #3b82f6);
+  min-height: 2px;
+  position: relative;
+}
+.hist-count {
+  position: absolute;
+  top: -20px;
+  left: 50%;
+  transform: translateX(-50%);
+  font-size: 0.72rem;
+  font-weight: 600;
+  color: var(--muted);
+}
+.hist-label {
+  font-size: 0.72rem;
+  color: var(--muted);
+  margin-top: 4px;
+}
+
+/* ── About page ────────────────────────────────────────────── */
+.about-grid {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 16px;
+  margin-top: 16px;
+}
+
+/* Architecture flow */
+.arch-flow {
+  display: flex;
+  align-items: center;
+  gap: 6px;
+  flex-wrap: wrap;
+  margin-top: 16px;
+  padding: 12px 0;
+}
+.arch-step {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  background: var(--bg2);
+  border: 1px solid var(--line);
+  border-radius: 10px;
+  padding: 10px 14px;
+}
+.arch-num {
+  width: 26px;
+  height: 26px;
+  border-radius: 50%;
+  background: var(--accent);
+  color: var(--bg);
+  font-weight: 800;
+  font-size: 0.82rem;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+}
+.arch-label {
+  font-size: 0.85rem;
+  font-weight: 500;
+}
+.arch-arrow {
+  color: var(--muted);
+  font-size: 1.2rem;
+}
+
+/* Triage cards */
+.triage-grid {
+  display: grid;
+  grid-template-columns: repeat(3, 1fr);
+  gap: 12px;
+  margin-top: 12px;
+}
+.triage-card {
+  background: var(--bg2);
+  border: 1px solid var(--line);
+  border-radius: 12px;
+  padding: 16px;
+}
+.triage-card p {
+  font-size: 0.88rem;
+  margin-top: 6px;
+  color: var(--muted);
+}
+.triage-card p strong {
+  color: var(--text);
+}
+.triage-header {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  margin-bottom: 8px;
+  font-size: 0.85rem;
+  color: var(--muted);
+}
+
+/* Ethics */
+.ethics-columns {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 24px;
+  margin-top: 12px;
+}
+.ethics-columns h4 {
+  font-size: 0.95rem;
+  margin-bottom: 8px;
+}
+.check-list,
+.cross-list {
+  list-style: none;
+  padding: 0;
+}
+.check-list li,
+.cross-list li {
+  padding: 5px 0;
+  padding-left: 24px;
+  position: relative;
+  font-size: 0.9rem;
+  color: var(--muted);
+}
+.check-list li::before {
+  content: "✓";
+  position: absolute;
+  left: 0;
+  color: var(--green);
+  font-weight: 700;
+}
+.cross-list li::before {
+  content: "✕";
+  position: absolute;
+  left: 0;
+  color: var(--red);
+  font-weight: 700;
+}
+
+/* Tech tags */
+.tech-tags {
+  display: flex;
+  flex-wrap: wrap;
+  gap: 8px;
+  margin-top: 4px;
+}
+.tech-tag {
+  padding: 5px 14px;
+  border-radius: 999px;
+  font-size: 0.82rem;
+  font-weight: 500;
+  background: rgba(110, 168, 254, 0.08);
+  border: 1px solid rgba(110, 168, 254, 0.2);
+  color: var(--accent);
+}
+
+/* ── Footer ────────────────────────────────────────────────── */
+.footer {
+  margin-top: 48px;
+  padding: 20px 0;
+  border-top: 1px solid var(--line);
+  text-align: center;
+  font-size: 0.85rem;
+  color: var(--muted);
+}
+.footer p + p {
+  margin-top: 4px;
+}
+
+/* ── Home Page ─────────────────────────────────────────────── */
+.home-hero {
+  text-align: center;
+  padding: 48px 0 12px;
+}
+.home-hero h1 {
+  font-size: 2.2rem;
+  font-weight: 800;
+}
+.home-hero p {
+  color: var(--muted);
+  margin-top: 8px;
+  max-width: 600px;
+  margin-left: auto;
+  margin-right: auto;
+}
+
+.home-cards {
+  display: grid;
+  grid-template-columns: 1fr 1fr;
+  gap: 20px;
+  margin-top: 32px;
+}
+
+.home-card {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  text-align: center;
+  padding: 40px 32px;
+  border-radius: var(--radius);
+  border: 1px solid var(--line);
+  background: linear-gradient(180deg, var(--panel2), var(--panel));
+  text-decoration: none;
+  color: var(--text);
+  transition: all 0.2s;
+}
+.home-card:hover {
+  border-color: var(--accent);
+  transform: translateY(-2px);
+  box-shadow: 0 8px 32px rgba(110, 168, 254, 0.1);
+}
+.home-card-icon {
+  color: var(--accent);
+  margin-bottom: 16px;
+}
+.home-card h2 {
+  font-size: 1.3rem;
+  font-weight: 700;
+  margin-bottom: 8px;
+}
+.home-card p {
+  color: var(--muted);
+  font-size: 0.92rem;
+  line-height: 1.5;
+}
+.home-card-action {
+  margin-top: 16px;
+  color: var(--accent);
+  font-weight: 600;
+  font-size: 0.9rem;
+}
+
+.home-cards-secondary {
+  grid-template-columns: repeat(3, 1fr);
+  margin-top: 16px;
+}
+.home-card-sm {
+  padding: 28px 24px;
+}
+.home-card-sm h3 {
+  font-size: 1.05rem;
+  font-weight: 700;
+  margin-bottom: 4px;
+}
+
+/* ── Page Header ───────────────────────────────────────────── */
+.page-header {
+  margin-bottom: 24px;
+}
+.page-header h1 {
+  font-size: 1.8rem;
+  font-weight: 800;
+}
+.page-header p {
+  color: var(--muted);
+  margin-top: 6px;
+  line-height: 1.5;
+}
+
+/* ── Logs ───────────────────────────────────────────────────── */
+.log-summary {
+  margin-bottom: 12px;
+}
+.logs-table td code {
+  font-family: "SF Mono", "Cascadia Code", monospace;
+  font-size: 0.85rem;
+  color: var(--accent);
+}
+.log-actions {
+  display: flex;
+  gap: 6px;
+}
+
+/* ── Upload Page ───────────────────────────────────────────── */
+.upload-hero {
+  padding: 8px 0 6px;
+}
+.upload-hero h1 {
+  font-size: 1.8rem;
+  font-weight: 800;
+}
+.upload-hero p {
+  color: var(--muted);
+  margin-top: 6px;
+}
+
+.upload-panel {
+  position: relative;
+}
+
+.dropzone {
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  padding: 48px 24px;
+  border: 2px dashed var(--line);
+  border-radius: 12px;
+  cursor: pointer;
+  transition: all 0.2s;
+  color: var(--muted);
+}
+.dropzone:hover,
+.dropzone.dragover {
+  border-color: var(--accent);
+  background: rgba(110, 168, 254, 0.04);
+}
+.dropzone-text {
+  font-size: 1.05rem;
+  font-weight: 600;
+  margin-top: 12px;
+  color: var(--text);
+}
+
+.file-info {
+  display: flex;
+  align-items: center;
+  gap: 10px;
+  padding: 14px 16px;
+  border: 1px solid var(--accent);
+  border-radius: 10px;
+  background: rgba(110, 168, 254, 0.06);
+  color: var(--accent);
+  font-weight: 500;
+}
+.file-info span {
+  flex: 1;
+}
+
+.btn-primary {
+  margin-top: 16px;
+  width: 100%;
+  justify-content: center;
+  padding: 12px 24px;
+  background: linear-gradient(135deg, #3b82f6, #6366f1);
+  border-color: #3b82f6;
+  font-weight: 600;
+  font-size: 0.95rem;
+}
+.btn-primary:hover {
+  background: linear-gradient(135deg, #2563eb, #4f46e5);
+}
+.btn-primary:disabled {
+  opacity: 0.4;
+  cursor: not-allowed;
+}
+
+.loading-overlay {
+  position: absolute;
+  inset: 0;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  background: rgba(17, 28, 51, 0.95);
+  border-radius: var(--radius);
+  z-index: 10;
+  gap: 16px;
+}
+
+.spinner {
+  width: 48px;
+  height: 48px;
+  border: 3px solid var(--line);
+  border-top-color: var(--accent);
+  border-radius: 50%;
+  animation: spin 0.8s linear infinite;
+}
+@keyframes spin {
+  to {
+    transform: rotate(360deg);
+  }
+}
+
+.steps-grid {
+  display: grid;
+  grid-template-columns: repeat(4, 1fr);
+  gap: 16px;
+  margin-top: 12px;
+}
+.step {
+  display: flex;
+  align-items: flex-start;
+  gap: 12px;
+}
+.step-num {
+  width: 28px;
+  height: 28px;
+  border-radius: 50%;
+  background: var(--accent);
+  color: var(--bg);
+  font-weight: 800;
+  font-size: 0.82rem;
+  display: flex;
+  align-items: center;
+  justify-content: center;
+  flex-shrink: 0;
+}
+.step-text strong {
+  font-size: 0.92rem;
+}
+
+/* ── Flash Messages ────────────────────────────────────────── */
+.flash-messages {
+  margin-bottom: 16px;
+}
+.flash {
+  padding: 12px 16px;
+  border-radius: 10px;
+  font-size: 0.9rem;
+  margin-bottom: 8px;
+}
+.flash-error {
+  background: rgba(251, 113, 133, 0.1);
+  border: 1px solid rgba(251, 113, 133, 0.3);
+  color: var(--red);
+}
+.flash-success {
+  background: rgba(52, 211, 153, 0.1);
+  border: 1px solid rgba(52, 211, 153, 0.3);
+  color: var(--green);
+}
+
+/* ── Upload Tabs ───────────────────────────────────────────── */
+.upload-tabs {
+  display: flex;
+  gap: 4px;
+  margin-bottom: 0;
+  border-bottom: 2px solid var(--line);
+  padding-bottom: 0;
+}
+.upload-tab {
+  padding: 10px 20px;
+  background: none;
+  border: none;
+  color: var(--muted);
+  font-size: 0.9rem;
+  font-weight: 600;
+  font-family: inherit;
+  cursor: pointer;
+  border-bottom: 2px solid transparent;
+  margin-bottom: -2px;
+  transition: all 0.15s;
+}
+.upload-tab:hover {
+  color: var(--text);
+}
+.upload-tab.active {
+  color: var(--accent);
+  border-bottom-color: var(--accent);
+}
+.tab-panel {
+  display: none;
+  margin-top: 16px;
+}
+.tab-panel.active {
+  display: block;
+}
+
+/* ── Directory Input ───────────────────────────────────────── */
+.dir-label {
+  display: block;
+  font-weight: 600;
+  margin-bottom: 8px;
+  font-size: 0.92rem;
+}
+.dir-input-row {
+  display: flex;
+  gap: 10px;
+}
+.dir-input-row .input {
+  flex: 1;
+  padding: 10px 14px;
+  font-size: 0.92rem;
+  font-family: "SF Mono", "Cascadia Code", monospace;
+  background: var(--panel);
+  border: 1px solid var(--line);
+  border-radius: var(--radius);
+  color: var(--text);
+  outline: none;
+  transition: border-color 0.15s;
+}
+.dir-input-row .input:focus {
+  border-color: var(--accent);
+}
+.dir-input-row .btn-primary {
+  margin-top: 0;
+  width: auto;
+  white-space: nowrap;
+}
+
+/* ── Batch Progress Page ───────────────────────────────────── */
+.batch-header {
+  margin-bottom: 20px;
+}
+.batch-header h1 {
+  font-size: 1.6rem;
+  font-weight: 800;
+}
+.batch-panel {
+  padding: 24px;
+}
+.batch-stats-row {
+  display: grid;
+  grid-template-columns: repeat(4, 1fr);
+  gap: 12px;
+  margin-bottom: 20px;
+}
+.batch-stat {
+  text-align: center;
+}
+.batch-stat-label {
+  display: block;
+  font-size: 0.78rem;
+  color: var(--muted);
+  font-weight: 600;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+}
+.batch-stat-value {
+  display: block;
+  font-size: 1.6rem;
+  font-weight: 800;
+  margin-top: 2px;
+}
+.batch-stat.accent-green .batch-stat-value {
+  color: var(--green);
+}
+.batch-stat.accent-red .batch-stat-value {
+  color: var(--red);
+}
+
+.progress-track {
+  width: 100%;
+  height: 12px;
+  background: var(--panel);
+  border: 1px solid var(--line);
+  border-radius: 6px;
+  overflow: hidden;
+}
+.progress-fill {
+  height: 100%;
+  background: linear-gradient(90deg, #3b82f6, #6366f1);
+  border-radius: 6px;
+  transition: width 0.4s ease;
+}
+.progress-text {
+  display: flex;
+  justify-content: space-between;
+  margin-top: 8px;
+  font-size: 0.88rem;
+  font-weight: 600;
+}
+
+.batch-feed {
+  list-style: none;
+  padding: 0;
+  margin: 0;
+}
+.batch-feed li {
+  padding: 6px 0;
+  border-bottom: 1px solid var(--line);
+  font-size: 0.88rem;
+}
+.batch-feed li a {
+  color: var(--accent);
+  text-decoration: none;
+}
+.batch-feed li a:hover {
+  text-decoration: underline;
+}
+
+.batch-done-panel {
+  text-align: center;
+  padding: 40px 24px;
+}
+.batch-done-icon {
+  margin-bottom: 16px;
+}
+.batch-done-panel h2 {
+  font-size: 1.5rem;
+  font-weight: 800;
+  margin-bottom: 8px;
+}
+.batch-done-actions {
+  display: flex;
+  gap: 12px;
+  justify-content: center;
+  margin-top: 20px;
+}
+.batch-done-actions .btn-primary {
+  width: auto;
+  margin-top: 0;
+}
+
+.batch-fail-list {
+  padding-left: 20px;
+}
+.batch-fail-list li {
+  color: var(--red);
+  font-family: "SF Mono", "Cascadia Code", monospace;
+  font-size: 0.85rem;
+  padding: 3px 0;
+}
+.text-red {
+  color: var(--red);
+}
+
+/* ── Responsive ────────────────────────────────────────────── */
+@media (max-width: 1024px) {
+  .stats-row {
+    grid-template-columns: repeat(3, 1fr);
+  }
+  .home-cards-secondary {
+    grid-template-columns: 1fr;
+  }
+  .topbar-inner {
+    padding: 14px 16px;
+  }
+  .detail-grid,
+  .eval-grid,
+  .about-grid,
+  .ethics-columns {
+    grid-template-columns: 1fr;
+  }
+  .triage-grid,
+  .band-grid {
+    grid-template-columns: 1fr;
+  }
+  .arch-flow {
+    justify-content: center;
+  }
+  .home-cards {
+    grid-template-columns: 1fr;
+  }
+  .steps-grid {
+    grid-template-columns: 1fr 1fr;
+  }
+  .batch-stats-row {
+    grid-template-columns: repeat(2, 1fr);
+  }
+}
+@media (max-width: 640px) {
+  .stats-row {
+    grid-template-columns: 1fr 1fr;
+  }
+  .topbar-inner {
+    flex-direction: column;
+    gap: 8px;
+  }
+  .nav-links {
+    width: 100%;
+    justify-content: center;
+    flex-wrap: wrap;
+  }
+  .detail-header {
+    flex-direction: column;
+  }
+  .filters {
+    flex-direction: column;
+  }
+  .home-hero h1 {
+    font-size: 1.7rem;
+  }
+  .home-card {
+    padding: 28px 20px;
+  }
+  .steps-grid {
+    grid-template-columns: 1fr;
+  }
+  .upload-tabs {
+    flex-wrap: wrap;
+  }
+  .dir-input-row {
+    flex-direction: column;
+  }
+  .dir-input-row .btn-primary {
+    width: 100%;
+  }
+  .batch-done-actions {
+    flex-direction: column;
+  }
+}

templates/about.html

@@ -0,0 +1,274 @@
+{% extends "base.html" %}
+
+{% block title %}About — ICH Screening{% 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
+      and Clinical Reporting
+    </p>
+  </div>
+</section>
+
+<!-- System Overview -->
+<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
+    explainability, confidence calibration, and structured clinical reporting to
+    support — not replace — medical decision-making.
+  </p>
+  <div class="arch-flow">
+    <div class="arch-step">
+      <div class="arch-num">1</div>
+      <div class="arch-label">CT Brain Image Input</div>
+    </div>
+    <div class="arch-arrow">→</div>
+    <div class="arch-step">
+      <div class="arch-num">2</div>
+      <div class="arch-label">Preprocessing &amp; CT Windowing</div>
+    </div>
+    <div class="arch-arrow">→</div>
+    <div class="arch-step">
+      <div class="arch-num">3</div>
+      <div class="arch-label">2.5D Detection (EfficientNet-B4)</div>
+    </div>
+    <div class="arch-arrow">→</div>
+    <div class="arch-step">
+      <div class="arch-num">4</div>
+      <div class="arch-label">Grad-CAM Explainability</div>
+    </div>
+    <div class="arch-arrow">→</div>
+    <div class="arch-step">
+      <div class="arch-num">5</div>
+      <div class="arch-label">Confidence Calibration</div>
+    </div>
+    <div class="arch-arrow">→</div>
+    <div class="arch-step">
+      <div class="arch-num">6</div>
+      <div class="arch-label">Clinical Report</div>
+    </div>
+  </div>
+</section>
+
+<!-- Technical Details -->
+<section class="about-grid">
+  <article class="panel">
+    <h3>Model Architecture</h3>
+    <div class="kv-group">
+      <div class="kv">
+        <span>Architecture</span><strong>EfficientNet-B4 (timm)</strong>
+      </div>
+      <div class="kv">
+        <span>Input Representation</span><strong>2.5D (prev/center/next)</strong>
+      </div>
+      <div class="kv">
+        <span>Channels</span><strong>9 (3 CT windows × 3 slices)</strong>
+      </div>
+      <div class="kv"><span>Outputs</span><strong>6 heads (any + 5 subtypes)</strong></div>
+      <div class="kv">
+        <span>Inference Strategy</span><strong>5-fold ensemble (logit averaging)</strong>
+      </div>
+    </div>
+  </article>
+
+  <article class="panel">
+    <h3>CT Preprocessing</h3>
+    <div class="kv-group">
+      <div class="kv">
+        <span>Brain Window</span><strong>WC=40, WW=80</strong>
+      </div>
+      <div class="kv">
+        <span>Subdural Window</span><strong>WC=75, WW=215</strong>
+      </div>
+      <div class="kv">
+        <span>Soft Tissue Window</span><strong>WC=40, WW=380</strong>
+      </div>
+      <div class="kv">
+        <span>Channels</span><strong>3 (one per window)</strong>
+      </div>
+      <div class="kv">
+        <span>Format</span><strong>DICOM → HU → windowed RGB</strong>
+      </div>
+    </div>
+  </article>
+
+  <article class="panel">
+    <h3>Calibration</h3>
+    <div class="kv-group">
+      <div class="kv">
+        <span>Method</span
+        ><strong>{{ calib.get('method', calib.get('best_method', 'N/A')) }}</strong>
+      </div>
+      {% if calib %}
+      <div class="kv">
+        <span>Temperature</span
+        ><strong>{{ '%.4f'|format(calib.temperature) }}</strong>
+      </div>
+      <div class="kv">
+        <span>Threshold</span
+        ><strong>{{ '%.4f'|format(calib.calibrated_threshold) }}</strong>
+      </div>
+      {% endif %}
+      <div class="kv">
+        <span>ECE (Raw → Calibrated)</span
+        ><strong>{{ '%.4f'|format(calib.get('raw_ece', 0.0)) }} → {{ '%.4f'|format(calib.get('cal_ece', 0.0)) }}</strong>
+      </div>
+      <div class="kv">
+        <span>Bands</span
+        ><strong>
+          HIGH (≥{{ '%.2f'|format(calib.get('high_threshold', 0.7)) }}) ·
+          MEDIUM ({{ '%.2f'|format(calib.get('low_threshold', 0.3)) }}–{{ '%.2f'|format(calib.get('high_threshold', 0.7)) }}) ·
+          LOW (&lt;{{ '%.2f'|format(calib.get('low_threshold', 0.3)) }})
+        </strong>
+      </div>
+    </div>
+  </article>
+
+  <article class="panel">
+    <h3>Explainability</h3>
+    <div class="kv-group">
+      <div class="kv"><span>Method</span><strong>Grad-CAM</strong></div>
+      <div class="kv">
+        <span>Target Layer</span><strong>Last convolutional block</strong>
+      </div>
+      <div class="kv">
+        <span>Output</span><strong>Heatmap overlay on input</strong>
+      </div>
+      <div class="kv">
+        <span>Purpose</span><strong>Visual evidence for review</strong>
+      </div>
+    </div>
+  </article>
+</section>
+
+<!-- Confidence-Aware Triage -->
+<section class="panel" style="margin-top: 16px">
+  <h3>Confidence-Aware Triage System</h3>
+  <p>
+    Instead of a simple binary output, the system incorporates prediction
+    confidence into a three-band triage workflow:
+  </p>
+
+  <div class="triage-grid">
+    <div class="triage-card triage-high">
+      <div class="triage-header">
+        <span class="badge badge-high">HIGH</span>
+        <span>≥ {{ '%.2f'|format(calib.get('high_threshold', 0.7)) }} calibrated probability</span>
+      </div>
+      <p><strong>If positive:</strong> Urgent radiologist review recommended</p>
+      <p><strong>If negative:</strong> Standard workflow — no urgent action</p>
+    </div>
+
+    <div class="triage-card triage-medium">
+      <div class="triage-header">
+        <span class="badge badge-medium">MEDIUM</span>
+        <span>{{ '%.2f'|format(calib.get('low_threshold', 0.3)) }} – {{ '%.2f'|format(calib.get('high_threshold', 0.7)) }}</span>
+      </div>
+      <p>
+        <strong>If positive:</strong> Prioritised radiologist review recommended
+      </p>
+      <p>
+        <strong>If negative:</strong> Standard workflow — manual review if
+        clinically indicated
+      </p>
+    </div>
+
+    <div class="triage-card triage-low">
+      <div class="triage-header">
+        <span class="badge badge-low">LOW</span>
+        <span>&lt; {{ '%.2f'|format(calib.get('low_threshold', 0.3)) }}</span>
+      </div>
+      <p>
+        <strong>If positive:</strong> Radiologist review recommended — low
+        confidence
+      </p>
+      <p>
+        <strong>If negative:</strong> Manual review recommended — model
+        uncertainty high
+      </p>
+    </div>
+  </div>
+</section>
+
+<!-- Dataset -->
+<section class="panel" style="margin-top: 16px">
+  <h3>Dataset</h3>
+  <div class="kv-group" style="max-width: 600px">
+    <div class="kv">
+      <span>Source</span><strong>RSNA Intracranial Hemorrhage Detection</strong>
+    </div>
+    <div class="kv">
+      <span>Modality</span><strong>CT brain (axial slices)</strong>
+    </div>
+    <div class="kv"><span>Format</span><strong>DICOM</strong></div>
+    <div class="kv">
+      <span>Task</span><strong>Any-hemorrhage screening + subtype-aware outputs</strong>
+    </div>
+  </div>
+</section>
+
+<!-- Ethical Considerations -->
+<section class="panel" style="margin-top: 16px">
+  <h3>Ethical Considerations &amp; Limitations</h3>
+
+  <div class="ethics-columns">
+    <div>
+      <h4>This System Is:</h4>
+      <ul class="check-list">
+        <li>A screening and decision-support tool</li>
+        <li>Designed to assist, not replace, medical professionals</li>
+        <li>Transparent via Grad-CAM visual evidence</li>
+        <li>Calibrated for reliable confidence scores</li>
+        <li>Built on publicly available, ethically sourced data</li>
+      </ul>
+    </div>
+    <div>
+      <h4>This System Is NOT:</h4>
+      <ul class="cross-list">
+        <li>A diagnostic device or medical diagnosis tool</li>
+        <li>A replacement for qualified radiologist review</li>
+        <li>Cleared for standalone clinical deployment</li>
+        <li>A substitute for clinical subtype confirmation</li>
+        <li>Validated for real-time hospital use</li>
+      </ul>
+    </div>
+  </div>
+</section>
+
+<!-- Disclaimer -->
+<section class="disclaimer-box" style="margin-top: 16px">
+  <strong>Important Disclaimer:</strong>
+  This system is produced by an AI-assisted screening tool and does NOT
+  constitute a medical diagnosis. All screening findings must be reviewed and
+  confirmed by a qualified, licensed medical professional before any clinical
+  decision is made. The system is intended solely as a decision-support aid in a
+  screening workflow and is not cleared for standalone diagnostic use.
+</section>
+
+<!-- Technology Stack -->
+<section class="panel" style="margin-top: 16px">
+  <h3>Technology Stack</h3>
+  <div class="tech-tags">
+    <span class="tech-tag">Python</span>
+    <span class="tech-tag">PyTorch</span>
+    <span class="tech-tag">EfficientNet-B4</span>
+    <span class="tech-tag">timm</span>
+    <span class="tech-tag">2.5D Context</span>
+    <span class="tech-tag">5-Fold Ensemble</span>
+    <span class="tech-tag">Isotonic Calibration</span>
+    <span class="tech-tag">OpenCV</span>
+    <span class="tech-tag">NumPy</span>
+    <span class="tech-tag">Pandas</span>
+    <span class="tech-tag">Matplotlib</span>
+    <span class="tech-tag">Grad-CAM</span>
+    <span class="tech-tag">Flask</span>
+    <span class="tech-tag">pydicom</span>
+    <span class="tech-tag">scikit-learn</span>
+  </div>
+</section>
+{% endblock %}

templates/base.html

@@ -0,0 +1,76 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>{% block title %}ICH Screening Dashboard{% endblock %}</title>
+    <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"
+    />
+    <link
+      rel="stylesheet"
+      href="{{ url_for('static', filename='styles.css') }}"
+    />
+    {% block head %}{% endblock %}
+  </head>
+  <body>
+    <!-- ── Top navigation ─────────────────────────────────────────────── -->
+    <header class="topbar">
+      <div class="topbar-inner">
+        <a class="brand" href="{{ url_for('home') }}">
+          <span class="brand-icon">
+            <svg
+              width="22"
+              height="22"
+              viewBox="0 0 24 24"
+              fill="none"
+              stroke="currentColor"
+              stroke-width="2"
+              stroke-linecap="round"
+              stroke-linejoin="round"
+            >
+              <path d="M22 12h-4l-3 9L9 3l-3 9H2" />
+            </svg>
+          </span>
+          <span>ICH Screening</span>
+        </a>
+
+        <nav class="nav-links">
+          <a href="{{ url_for('home') }}"
+             class="{% if request.endpoint == 'home' %}active{% endif %}">Home</a>
+          <a href="{{ url_for('upload') }}"
+             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>
+          <a href="{{ url_for('logs_page') }}"
+             class="{% if request.endpoint == 'logs_page' %}active{% endif %}">Logs</a>
+          <a href="{{ url_for('evaluation') }}"
+             class="{% if request.endpoint == 'evaluation' %}active{% endif %}">Evaluation</a>
+          <a href="{{ url_for('about') }}"
+             class="{% if request.endpoint == 'about' %}active{% endif %}">About</a>
+        </nav>
+      </div>
+    </header>
+
+    <!-- ── Main content ────────────────────────────────────────────────── -->
+    <main class="container page">{% block content %}{% endblock %}</main>
+
+    <!-- ── Footer ──────────────────────────────────────────────────────── -->
+    <footer class="footer">
+      <div class="container footer-inner">
+        <p>
+          AI-Assisted CT-Based Intracranial Hemorrhage Detection &mdash;
+          Screening Tool, Not a Diagnostic Device
+        </p>
+        <p class="muted small">
+          All findings must be reviewed by a qualified medical professional.
+        </p>
+      </div>
+    </footer>
+
+    {% block scripts %}{% endblock %}
+  </body>
+</html>

templates/batch_progress.html

@@ -0,0 +1,184 @@
+{% extends "base.html" %}
+
+{% block title %}Batch Processing — ICH Screening{% endblock %}
+
+{% block content %}
+<section class="breadcrumb">
+  <a href="{{ url_for('home') }}">Home</a>
+  <span class="sep">/</span>
+  <a href="{{ url_for('upload') }}">Upload</a>
+  <span class="sep">/</span>
+  <span>Batch {{ batch_id }}</span>
+</section>
+
+<section class="batch-header">
+  <h1 id="batchTitle">Processing Batch&hellip;</h1>
+  <p class="muted" id="batchSubtitle">
+    Analyzing {{ batch.total }} DICOM file{{ 's' if batch.total != 1 }} — please keep this page open.
+  </p>
+</section>
+
+<!-- ── Progress bar ────────────────────────────────────────────────── -->
+<section class="panel batch-panel">
+  <div class="batch-stats-row">
+    <div class="batch-stat">
+      <span class="batch-stat-label">Total</span>
+      <span class="batch-stat-value" id="statTotal">{{ batch.total }}</span>
+    </div>
+    <div class="batch-stat">
+      <span class="batch-stat-label">Processed</span>
+      <span class="batch-stat-value" id="statProcessed">0</span>
+    </div>
+    <div class="batch-stat accent-green">
+      <span class="batch-stat-label">Succeeded</span>
+      <span class="batch-stat-value" id="statSucceeded">0</span>
+    </div>
+    <div class="batch-stat accent-red">
+      <span class="batch-stat-label">Failed</span>
+      <span class="batch-stat-value" id="statFailed">0</span>
+    </div>
+  </div>
+
+  <div class="progress-track">
+    <div class="progress-fill" id="progressFill" style="width: 0%"></div>
+  </div>
+  <div class="progress-text">
+    <span id="progressPct">0%</span>
+    <span id="currentFile" class="muted"></span>
+  </div>
+</section>
+
+<!-- ── Live feed of recent results ─────────────────────────────────── -->
+<section class="panel" id="feedPanel" style="display: none">
+  <h3>Recent Results</h3>
+  <ul class="batch-feed" id="batchFeed"></ul>
+</section>
+
+<!-- ── Completion summary (shown when done) ────────────────────────── -->
+<section class="panel batch-done-panel" id="donePanel" style="display: none">
+  <div class="batch-done-icon">
+    <svg width="48" height="48" viewBox="0 0 24 24" fill="none"
+         stroke="var(--green)" stroke-width="2">
+      <path d="M22 11.08V12a10 10 0 1 1-5.93-9.14" />
+      <polyline points="22 4 12 14.01 9 11.01" />
+    </svg>
+  </div>
+  <h2>Batch Complete</h2>
+  <p class="muted" id="doneSummary"></p>
+  <div class="batch-done-actions">
+    <a href="{{ url_for('reports') }}" class="btn btn-primary">View Reports</a>
+    <a href="{{ url_for('upload') }}" class="btn">Upload More</a>
+  </div>
+</section>
+
+<!-- ── Failed files (shown only if failures) ───────────────────────── -->
+<section class="panel" id="failPanel" style="display: none">
+  <h3 class="text-red">Failed Files</h3>
+  <ul class="batch-fail-list" id="failList"></ul>
+</section>
+{% endblock %}
+
+{% block scripts %}
+<script>
+(function () {
+  var BATCH_ID    = "{{ batch_id }}";
+  var POLL_MS     = 1000;
+  var statusUrl   = "/batch/status/" + BATCH_ID;
+  var reportsUrl  = "{{ url_for('reports') }}";
+
+  var title        = document.getElementById("batchTitle");
+  var subtitle     = document.getElementById("batchSubtitle");
+  var fill         = document.getElementById("progressFill");
+  var pctLabel     = document.getElementById("progressPct");
+  var currentFile  = document.getElementById("currentFile");
+  var statTotal    = document.getElementById("statTotal");
+  var statProc     = document.getElementById("statProcessed");
+  var statOK       = document.getElementById("statSucceeded");
+  var statFail     = document.getElementById("statFailed");
+  var feedPanel    = document.getElementById("feedPanel");
+  var feedList     = document.getElementById("batchFeed");
+  var donePanel    = document.getElementById("donePanel");
+  var doneSummary  = document.getElementById("doneSummary");
+  var failPanel    = document.getElementById("failPanel");
+  var failList     = document.getElementById("failList");
+
+  var prevIds = [];   // track already-shown image_ids
+
+  function poll() {
+    fetch(statusUrl)
+      .then(function (r) { return r.json(); })
+      .then(function (d) {
+        var pct = d.total > 0 ? Math.round(d.processed / d.total * 100) : 0;
+
+        /* Update numbers */
+        statTotal.textContent = d.total;
+        statProc.textContent  = d.processed;
+        statOK.textContent    = d.succeeded;
+        statFail.textContent  = d.failed_count;
+
+        /* Progress bar */
+        fill.style.width = pct + "%";
+        pctLabel.textContent = pct + "%";
+
+        /* Current file label */
+        if (d.current_file) {
+          currentFile.textContent = "Processing: " + d.current_file;
+        } else {
+          currentFile.textContent = "";
+        }
+
+        /* Live feed of recently processed IDs */
+        if (d.image_ids && d.image_ids.length) {
+          feedPanel.style.display = "block";
+          d.image_ids.forEach(function (iid) {
+            if (prevIds.indexOf(iid) === -1) {
+              prevIds.push(iid);
+              var li = document.createElement("li");
+              var a  = document.createElement("a");
+              a.href = "/case/" + iid;
+              a.textContent = iid;
+              li.appendChild(a);
+              feedList.insertBefore(li, feedList.firstChild);
+              /* Keep max 20 items visible */
+              while (feedList.children.length > 20) {
+                feedList.removeChild(feedList.lastChild);
+              }
+            }
+          });
+        }
+
+        /* Done? */
+        if (d.status === "completed" || d.status === "failed") {
+          title.textContent = "Batch Complete";
+          subtitle.textContent = "";
+          donePanel.style.display = "block";
+          doneSummary.textContent =
+            d.succeeded + " of " + d.total + " files processed successfully" +
+            (d.failed_count > 0 ? ", " + d.failed_count + " failed" : "") + ".";
+
+          /* Show failed files */
+          if (d.failed_ids && d.failed_ids.length) {
+            failPanel.style.display = "block";
+            d.failed_ids.forEach(function (fid) {
+              var li = document.createElement("li");
+              li.textContent = fid;
+              failList.appendChild(li);
+            });
+          }
+          return; /* stop polling */
+        }
+
+        /* Keep polling */
+        setTimeout(poll, POLL_MS);
+      })
+      .catch(function () {
+        /* Network error — retry after a longer delay */
+        setTimeout(poll, POLL_MS * 3);
+      });
+  }
+
+  /* Start polling immediately */
+  poll();
+})();
+</script>
+{% endblock %}

templates/detail.html

@@ -0,0 +1,171 @@
+{% extends "base.html" %}
+
+{% block title %}{{ row.image_id }} — Report{% endblock %}
+
+{% block content %}
+<!-- Breadcrumb -->
+<section class="breadcrumb">
+  <a href="{{ url_for('home') }}">Home</a>
+  <span class="sep">/</span>
+  <a href="{{ url_for('reports') }}">Reports</a>
+  <span class="sep">/</span>
+  <span class="mono">{{ row.image_id }}</span>
+</section>
+
+<!-- Header -->
+<section class="detail-header">
+  <div>
+    <h1 class="mono">{{ row.image_id }}</h1>
+    <p>
+      {% if row.is_positive %}
+      <span class="dot dot-red"></span> {{ row.outcome }}
+      {% else %}
+      <span class="dot dot-green"></span> {{ row.outcome }}
+      {% endif %}
+    </p>
+    <p class="muted small" style="margin-top: 4px">
+      {% if row.date_display != '—' %}
+      Generated: {{ row.date_display }} UTC
+      {% endif %}
+      {% if payload and payload.report_id %}
+       &middot; Report ID: {{ payload.report_id }}
+      {% endif %}
+    </p>
+  </div>
+  <div class="detail-actions">
+    {% if row.report_file %}
+    <a class="btn"
+       href="{{ url_for('serve_report_json', filename=row.report_file) }}"
+       target="_blank">
+      <svg width="14" height="14" viewBox="0 0 24 24" fill="none"
+           stroke="currentColor" stroke-width="2">
+        <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z" />
+        <polyline points="14 2 14 8 20 8" />
+      </svg>
+      Raw JSON
+    </a>
+    {% endif %}
+    <a class="btn" href="{{ url_for('reports') }}">← Back</a>
+  </div>
+</section>
+
+<!-- Two-column grid -->
+<section class="detail-grid">
+  <!-- Left: Prediction Details -->
+  <article class="panel">
+    <h3>Prediction Summary</h3>
+    <div class="kv-group">
+      <div class="kv">
+        <span>Screening Outcome</span>
+        <strong>{{ row.outcome }}</strong>
+      </div>
+      <div class="kv">
+        <span>Calibrated Probability</span>
+        <strong>{{ '%.4f'|format(row.cal_prob) if row.cal_prob is not none else 'N/A' }}</strong>
+      </div>
+      <div class="kv">
+        <span>Raw Probability</span>
+        <strong>{{ '%.4f'|format(row.raw_prob) if row.raw_prob is not none else 'N/A' }}</strong>
+      </div>
+      <div class="kv">
+        <span>Confidence Band</span>
+        <strong><span class="badge badge-{{ row.band|lower }}">{{ row.band }}</span></strong>
+      </div>
+      <div class="kv">
+        <span>Triage Action</span>
+        <strong>{{ row.triage }}</strong>
+      </div>
+      <div class="kv">
+        <span>Urgency</span>
+        <strong><span class="badge badge-{{ row.urgency|lower }}">{{ row.urgency }}</span></strong>
+      </div>
+      <div class="kv">
+        <span>Ground Truth</span>
+        <strong>{{ row.true_label if row.true_label and row.true_label != 'N/A' else 'Not available' }}</strong>
+      </div>
+      <div class="kv">
+        <span>Report Date</span>
+        <strong>{{ row.date_display }}</strong>
+      </div>
+    </div>
+
+    <!-- Confidence bar -->
+    {% if row.cal_prob is not none %}
+    <div class="prob-bar-wrap">
+      <div class="prob-bar-label">
+        <span>0</span>
+        <span>Calibrated probability</span>
+        <span>1</span>
+      </div>
+      <div class="prob-bar">
+        <div class="prob-fill {% if row.cal_prob >= 0.75 %}fill-high{% elif row.cal_prob >= 0.35 %}fill-medium{% else %}fill-low{% endif %}"
+             style="width: {{ (row.cal_prob * 100)|round(1) }}%"></div>
+        <div class="prob-marker"
+             style="left: {{ (row.cal_prob * 100)|round(1) }}%">
+          {{ '%.2f'|format(row.cal_prob) }}
+        </div>
+      </div>
+    </div>
+    {% endif %}
+  </article>
+
+  <!-- Right: Grad-CAM -->
+  <article class="panel">
+    <h3>Grad-CAM Visualization</h3>
+    {% if row.gradcam_file %}
+    <img class="heatmap-img"
+         src="{{ url_for('serve_gradcam', filename=row.gradcam_file) }}"
+         alt="Grad-CAM for {{ row.image_id }}" />
+    <p class="muted small" style="margin-top: 10px">
+      Highlighted regions indicate areas with greatest influence on the
+      screening decision. These are <strong>not</strong> confirmed anatomical
+      findings.
+    </p>
+    {% else %}
+    <div class="empty-state">
+      <svg width="48" height="48" viewBox="0 0 24 24" fill="none"
+           stroke="currentColor" stroke-width="1.5" opacity="0.3">
+        <rect x="3" y="3" width="18" height="18" rx="2" />
+        <circle cx="8.5" cy="8.5" r="1.5" />
+        <path d="m21 15-5-5L5 21" />
+      </svg>
+      <p class="muted">No Grad-CAM heatmap available for this case.</p>
+    </div>
+    {% endif %}
+  </article>
+</section>
+
+<!-- Model info (from payload) -->
+{% if payload and payload.screening_module %}
+<section class="panel" style="margin-top: 16px">
+  <h3>Model Information</h3>
+  <div class="kv-group" style="max-width: 500px">
+    <div class="kv">
+      <span>Architecture</span>
+      <strong>{{ payload.screening_module.architecture }}</strong>
+    </div>
+    <div class="kv">
+      <span>Version</span>
+      <strong>{{ payload.screening_module.version }}</strong>
+    </div>
+    <div class="kv">
+      <span>Calibration</span>
+      <strong>{{ payload.screening_module.calibration_method }}</strong>
+    </div>
+    <div class="kv">
+      <span>Decision Threshold</span>
+      <strong>{{ '%.4f'|format(payload.prediction.decision_threshold) }}</strong>
+    </div>
+  </div>
+</section>
+{% endif %}
+
+<!-- Disclaimer -->
+<section class="disclaimer-box">
+  <strong>Disclaimer:</strong>
+  This report is produced by an AI-assisted screening tool and does NOT
+  constitute a medical diagnosis. All screening findings must be reviewed and
+  confirmed by a qualified, licensed medical professional before any clinical
+  decision is made.
+</section>
+{% endblock %}

templates/evaluation.html

@@ -0,0 +1,185 @@
+{% extends "base.html" %}
+
+{% block title %}Evaluation — ICH Screening{% endblock %}
+
+{% block content %}
+<section class="hero">
+  <div class="hero-text">
+    <h1>Model Evaluation</h1>
+    <p>
+      Calibration metrics, confidence band analysis, and probability
+      distribution from the inference pipeline.
+    </p>
+  </div>
+</section>
+
+<!-- Calibration metrics -->
+{% if calib %}
+<section class="eval-grid">
+  <article class="panel">
+    <h3>Calibration Parameters</h3>
+    <div class="kv-group">
+      <div class="kv">
+        <span>Method</span><strong>{{ calib.get('method', 'N/A') }}</strong>
+      </div>
+      <div class="kv">
+        <span>Temperature</span
+        ><strong>{{ '%.4f'|format(calib.temperature) }}</strong>
+      </div>
+      <div class="kv">
+        <span>Decision Threshold</span
+        ><strong>{{ '%.4f'|format(calib.calibrated_threshold) }}</strong>
+      </div>
+      <div class="kv">
+        <span>Base Threshold</span
+        ><strong>{{ '%.4f'|format(calib.base_threshold) }}</strong>
+      </div>
+      <div class="kv">
+        <span>High Band ≥</span><strong>{{ calib.high_threshold }}</strong>
+      </div>
+      <div class="kv">
+        <span>Low Band &lt;</span><strong>{{ calib.low_threshold }}</strong>
+      </div>
+    </div>
+  </article>
+
+  <article class="panel">
+    <h3>Calibration Quality</h3>
+    <div class="metric-grid">
+      <div class="metric-card">
+        <div class="metric-label">ECE (Raw)</div>
+        <div class="metric-value">{{ '%.4f'|format(calib.raw_ece) }}</div>
+      </div>
+      <div class="metric-card">
+        <div class="metric-label">ECE (Calibrated)</div>
+        <div class="metric-value">{{ '%.4f'|format(calib.cal_ece) }}</div>
+      </div>
+      <div class="metric-card">
+        <div class="metric-label">Brier (Raw)</div>
+        <div class="metric-value">{{ '%.4f'|format(calib.raw_brier) }}</div>
+      </div>
+      <div class="metric-card">
+        <div class="metric-label">Brier (Cal)</div>
+        <div class="metric-value">{{ '%.4f'|format(calib.cal_brier) }}</div>
+      </div>
+    </div>
+    <p class="muted small" style="margin-top: 12px">
+      Temperature scaling adjusts logits by T={{
+      '%.4f'|format(calib.temperature) }} to produce better-calibrated
+      probabilities. Lower ECE = better calibration.
+    </p>
+  </article>
+</section>
+{% endif %}
+
+<!-- Normalization -->
+{% if norm %}
+<section class="panel" style="margin-top: 16px">
+  <h3>Normalization Statistics</h3>
+  <div class="kv-group" style="max-width: 500px">
+    <div class="kv">
+      <span>Mean (per channel)</span><strong>{{ norm.mean }}</strong>
+    </div>
+    <div class="kv">
+      <span>Std (per channel)</span><strong>{{ norm.std }}</strong>
+    </div>
+    <div class="kv">
+      <span>Computed from</span
+      ><strong>{{ norm.get('n_images', 'N/A') }} images</strong>
+    </div>
+  </div>
+</section>
+{% endif %}
+
+<!-- Confidence Band Breakdown -->
+<section class="panel" style="margin-top: 16px">
+  <h3>Confidence Band Analysis</h3>
+  <p class="muted small">
+    Distribution of {{ total }} processed cases across the three confidence
+    bands.
+  </p>
+
+  <div class="band-grid">
+    {% for bnd in ['HIGH', 'MEDIUM', 'LOW'] %} {% set d = band_data.get(bnd,
+    {'total': 0, 'positive': 0, 'negative': 0}) %}
+    <div class="band-card band-{{ bnd|lower }}">
+      <div class="band-header">
+        <span class="badge badge-{{ bnd|lower }}">{{ bnd }}</span>
+        <span class="band-total">{{ d.total }} cases</span>
+      </div>
+      <div class="band-bars">
+        <div class="band-bar-row">
+          <span class="band-bar-label">Positive</span>
+          <div class="band-bar">
+            <div
+              class="band-bar-fill fill-red"
+              style="width: {{ (d.positive / d.total * 100) if d.total else 0 }}%"
+            ></div>
+          </div>
+          <span class="band-bar-val">{{ d.positive }}</span>
+        </div>
+        <div class="band-bar-row">
+          <span class="band-bar-label">Negative</span>
+          <div class="band-bar">
+            <div
+              class="band-bar-fill fill-green"
+              style="width: {{ (d.negative / d.total * 100) if d.total else 0 }}%"
+            ></div>
+          </div>
+          <span class="band-bar-val">{{ d.negative }}</span>
+        </div>
+      </div>
+    </div>
+    {% endfor %}
+  </div>
+</section>
+
+<!-- Probability Distribution -->
+<section class="panel" style="margin-top: 16px">
+  <h3>Calibrated Probability Distribution</h3>
+  <p class="muted small">
+    Histogram of calibrated probabilities across all cases (10 bins).
+  </p>
+
+  <div class="histogram">
+    {% set max_bin = bins|max if bins|max > 0 else 1 %} {% for count in bins %}
+    <div class="hist-col">
+      <div
+        class="hist-bar"
+        style="height: {{ (count / max_bin * 180)|round }}px"
+        title="{{ '%.1f'|format(loop.index0 * 0.1) }}–{{ '%.1f'|format(loop.index0 * 0.1 + 0.1) }}: {{ count }}"
+      >
+        <span class="hist-count">{{ count }}</span>
+      </div>
+      <div class="hist-label">{{ '%.1f'|format(loop.index0 * 0.1) }}</div>
+    </div>
+    {% endfor %}
+  </div>
+</section>
+
+<!-- Summary stats -->
+<section class="panel" style="margin-top: 16px">
+  <h3>Summary Statistics</h3>
+  <div class="kv-group" style="max-width: 500px">
+    <div class="kv">
+      <span>Total processed</span><strong>{{ stats.total }}</strong>
+    </div>
+    <div class="kv">
+      <span>Positive (flagged)</span><strong>{{ stats.positive }}</strong>
+    </div>
+    <div class="kv">
+      <span>Negative</span><strong>{{ stats.negative }}</strong>
+    </div>
+    <div class="kv">
+      <span>Urgent escalations</span><strong>{{ stats.urgent }}</strong>
+    </div>
+    <div class="kv">
+      <span>Average calibrated prob</span
+      ><strong>{{ '%.4f'|format(stats.avg_cal_prob) }}</strong>
+    </div>
+    <div class="kv">
+      <span>Heatmaps generated</span><strong>{{ stats.heatmaps }}</strong>
+    </div>
+  </div>
+</section>
+{% endblock %}

templates/home.html

@@ -0,0 +1,130 @@
+{% extends "base.html" %}
+
+{% block title %}ICH Screening — Home{% endblock %}
+
+{% block content %}
+<section class="home-hero">
+  <h1>ICH Screening System</h1>
+  <p>
+    AI-Assisted CT-Based Intracranial Hemorrhage Detection with
+    Explainability and Clinical Reporting
+  </p>
+</section>
+
+<!-- Quick stats row -->
+{% if stats.total > 0 %}
+<section class="stats-row home-stats">
+  <div class="stat-card">
+    <div class="stat-label">Total Scans</div>
+    <div class="stat-value">{{ stats.total }}</div>
+  </div>
+  <div class="stat-card accent-red">
+    <div class="stat-label">Positive</div>
+    <div class="stat-value">{{ stats.positive }}</div>
+  </div>
+  <div class="stat-card accent-green">
+    <div class="stat-label">Negative</div>
+    <div class="stat-value">{{ stats.negative }}</div>
+  </div>
+  <div class="stat-card accent-orange">
+    <div class="stat-label">Urgent</div>
+    <div class="stat-value">{{ stats.urgent }}</div>
+  </div>
+  <div class="stat-card accent-blue">
+    <div class="stat-label">Positivity Rate</div>
+    <div class="stat-value">{{ '%.1f'|format(stats.pos_rate) }}%</div>
+  </div>
+  <div class="stat-card">
+    <div class="stat-label">Avg Cal. Prob</div>
+    <div class="stat-value">{{ '%.3f'|format(stats.avg_cal_prob) }}</div>
+  </div>
+</section>
+{% endif %}
+
+<!-- Main action cards -->
+<section class="home-cards">
+  <a href="{{ url_for('upload') }}" class="home-card">
+    <div class="home-card-icon">
+      <svg width="48" height="48" viewBox="0 0 24 24" fill="none"
+           stroke="currentColor" stroke-width="1.5"
+           stroke-linecap="round" stroke-linejoin="round">
+        <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4" />
+        <polyline points="17 8 12 3 7 8" />
+        <line x1="12" y1="3" x2="12" y2="15" />
+      </svg>
+    </div>
+    <h2>Upload Scans</h2>
+    <p>
+      Upload single or batch DICOM scans (.dcm / .zip) for AI-powered
+      hemorrhage screening with Grad-CAM visualization.
+    </p>
+    <span class="home-card-action">Upload files &rarr;</span>
+  </a>
+
+  <a href="{{ url_for('reports') }}" class="home-card">
+    <div class="home-card-icon">
+      <svg width="48" height="48" viewBox="0 0 24 24" fill="none"
+           stroke="currentColor" stroke-width="1.5"
+           stroke-linecap="round" stroke-linejoin="round">
+        <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z" />
+        <polyline points="14 2 14 8 20 8" />
+        <line x1="16" y1="13" x2="8" y2="13" />
+        <line x1="16" y1="17" x2="8" y2="17" />
+      </svg>
+    </div>
+    <h2>Past Reports</h2>
+    <p>
+      Browse {{ stats.total }} screening reports with confidence bands,
+      triage actions, and Grad-CAM heatmaps.
+    </p>
+    <span class="home-card-action">View reports &rarr;</span>
+  </a>
+</section>
+
+<!-- Secondary cards -->
+<section class="home-cards home-cards-secondary">
+  <a href="{{ url_for('logs_page') }}" class="home-card home-card-sm">
+    <div class="home-card-icon">
+      <svg width="32" height="32" viewBox="0 0 24 24" fill="none"
+           stroke="currentColor" stroke-width="1.5">
+        <path d="M4 19.5A2.5 2.5 0 0 1 6.5 17H20" />
+        <path d="M6.5 2H20v20H6.5A2.5 2.5 0 0 1 4 19.5v-15A2.5 2.5 0 0 1 6.5 2z" />
+      </svg>
+    </div>
+    <h3>Execution Logs</h3>
+    <p class="muted small">{{ log_count }} inference trace{{ 's' if log_count != 1 }} recorded</p>
+  </a>
+
+  <a href="{{ url_for('evaluation') }}" class="home-card home-card-sm">
+    <div class="home-card-icon">
+      <svg width="32" height="32" viewBox="0 0 24 24" fill="none"
+           stroke="currentColor" stroke-width="1.5">
+        <line x1="18" y1="20" x2="18" y2="10" />
+        <line x1="12" y1="20" x2="12" y2="4" />
+        <line x1="6" y1="20" x2="6" y2="14" />
+      </svg>
+    </div>
+    <h3>Model Evaluation</h3>
+    <p class="muted small">Calibration metrics and band analysis</p>
+  </a>
+
+  <a href="{{ url_for('about') }}" class="home-card home-card-sm">
+    <div class="home-card-icon">
+      <svg width="32" height="32" viewBox="0 0 24 24" fill="none"
+           stroke="currentColor" stroke-width="1.5">
+        <circle cx="12" cy="12" r="10" />
+        <line x1="12" y1="16" x2="12" y2="12" />
+        <line x1="12" y1="8" x2="12.01" y2="8" />
+      </svg>
+    </div>
+    <h3>About</h3>
+    <p class="muted small">System architecture and methodology</p>
+  </a>
+</section>
+
+<section class="disclaimer-box" style="margin-top: 32px">
+  <strong>Disclaimer:</strong>
+  This is an AI-assisted screening tool and does NOT constitute a medical
+  diagnosis. All findings must be reviewed by a qualified medical professional.
+</section>
+{% endblock %}

templates/logs.html

@@ -0,0 +1,70 @@
+{% extends "base.html" %}
+
+{% block title %}ICH Screening — Execution Logs{% endblock %}
+
+{% block content %}
+<section class="page-header">
+  <h1>Execution Logs</h1>
+  <p class="muted">
+    Inference execution traces recorded by <code>blackbox-recorder</code>.
+    Each upload generates a human-readable <strong>.txt</strong> report and
+    a machine-parseable <strong>.json</strong> trace.
+  </p>
+</section>
+
+{% if logs %}
+<div class="log-summary">
+  <span class="badge">{{ logs | length }} trace{{ 's' if logs | length != 1 }}</span>
+</div>
+
+<table class="data-table logs-table">
+  <thead>
+    <tr>
+      <th>#</th>
+      <th>Timestamp</th>
+      <th>Image ID</th>
+      <th>Size (KB)</th>
+      <th>Actions</th>
+    </tr>
+  </thead>
+  <tbody>
+    {% for entry in logs %}
+    <tr>
+      <td>{{ loop.index }}</td>
+      <td>{{ entry.timestamp }}</td>
+      <td><code>{{ entry.image_id }}</code></td>
+      <td>{{ entry.size_kb }}</td>
+      <td class="log-actions">
+        {% if entry.txt_file %}
+        <a href="{{ url_for('serve_log', filename=entry.txt_file) }}"
+           target="_blank" class="btn btn-sm" title="View text report">
+          TXT
+        </a>
+        {% endif %}
+        {% if entry.json_file %}
+        <a href="{{ url_for('serve_log', filename=entry.json_file) }}"
+           target="_blank" class="btn btn-sm btn-outline" title="View JSON trace">
+          JSON
+        </a>
+        {% endif %}
+      </td>
+    </tr>
+    {% endfor %}
+  </tbody>
+</table>
+
+{% else %}
+<div class="empty-state">
+  <svg width="64" height="64" viewBox="0 0 24 24" fill="none"
+       stroke="var(--muted)" stroke-width="1.2">
+    <path d="M4 19.5A2.5 2.5 0 0 1 6.5 17H20" />
+    <path d="M6.5 2H20v20H6.5A2.5 2.5 0 0 1 4 19.5v-15A2.5 2.5 0 0 1 6.5 2z" />
+  </svg>
+  <h3>No execution logs yet</h3>
+  <p class="muted">
+    Upload and screen a DICOM file to generate the first inference trace.
+  </p>
+  <a href="{{ url_for('upload') }}" class="btn">Upload a Scan</a>
+</div>
+{% endif %}
+{% endblock %}

templates/reports.html

@@ -0,0 +1,200 @@
+{% extends "base.html" %}
+
+{% block title %}Past Reports — ICH Screening{% endblock %}
+
+{% block content %}
+<section class="breadcrumb">
+  <a href="{{ url_for('home') }}">Home</a>
+  <span class="sep">/</span>
+  <span>Past Reports</span>
+</section>
+
+<section class="hero">
+  <div class="hero-text">
+    <h1>Past Reports</h1>
+    <p>Browse screening results, confidence bands, triage actions, and Grad-CAM
+       visualizations from previous inference runs.</p>
+  </div>
+</section>
+
+<!-- Stats summary cards -->
+<section class="stats-row">
+  <div class="stat-card">
+    <div class="stat-label">Total</div>
+    <div class="stat-value">{{ stats.total }}</div>
+  </div>
+  <div class="stat-card accent-green">
+    <div class="stat-label">Negative</div>
+    <div class="stat-value">{{ stats.negative }}</div>
+  </div>
+  <div class="stat-card accent-red">
+    <div class="stat-label">Positive</div>
+    <div class="stat-value">{{ stats.positive }}</div>
+  </div>
+  <div class="stat-card accent-orange">
+    <div class="stat-label">Urgent</div>
+    <div class="stat-value">{{ stats.urgent }}</div>
+  </div>
+  <div class="stat-card accent-blue">
+    <div class="stat-label">Positivity Rate</div>
+    <div class="stat-value">{{ '%.1f'|format(stats.pos_rate) }}%</div>
+  </div>
+  <div class="stat-card">
+    <div class="stat-label">Avg Prob</div>
+    <div class="stat-value">{{ '%.3f'|format(stats.avg_cal_prob) }}</div>
+  </div>
+</section>
+
+<!-- Calibration bar -->
+{% if calib %}
+<section class="info-bar">
+  <span>Temperature: <strong>{{ '%.4f'|format(calib.temperature) }}</strong></span>
+  <span>Threshold: <strong>{{ '%.4f'|format(calib.calibrated_threshold) }}</strong></span>
+  <span>ECE (raw): <strong>{{ '%.4f'|format(calib.raw_ece) }}</strong></span>
+  <span>ECE (cal): <strong>{{ '%.4f'|format(calib.cal_ece) }}</strong></span>
+</section>
+{% endif %}
+
+<!-- Filter bar -->
+<section class="panel">
+  <!-- prettier-ignore-start -->
+  <form method="get" class="filters">
+    <input type="text" name="q" value="{{ q }}"
+           placeholder="Search image ID or outcome..." />
+
+    <select name="outcome">
+      <option value="">All Outcomes</option>
+      <option value="POSITIVE" {% if outcome == "POSITIVE" %}selected{% endif %}>Positive</option>
+      <option value="NEGATIVE" {% if outcome == "NEGATIVE" %}selected{% endif %}>Negative</option>
+    </select>
+
+    <select name="band">
+      <option value="">All Bands</option>
+      <option value="HIGH"   {% if band == "HIGH"   %}selected{% endif %}>HIGH</option>
+      <option value="MEDIUM" {% if band == "MEDIUM" %}selected{% endif %}>MEDIUM</option>
+      <option value="LOW"    {% if band == "LOW"    %}selected{% endif %}>LOW</option>
+    </select>
+
+    <select name="urgency">
+      <option value="">All Urgency</option>
+      <option value="URGENT"   {% if urgency == "URGENT"   %}selected{% endif %}>URGENT</option>
+      <option value="STANDARD" {% if urgency == "STANDARD" %}selected{% endif %}>STANDARD</option>
+    </select>
+
+    <select name="sort">
+      <option value="">Default Sort</option>
+      <option value="date_desc" {% if sort == "date_desc" %}selected{% endif %}>Newest First</option>
+      <option value="date_asc"  {% if sort == "date_asc"  %}selected{% endif %}>Oldest First</option>
+      <option value="prob_desc" {% if sort == "prob_desc" %}selected{% endif %}>Highest Prob</option>
+      <option value="prob_asc"  {% if sort == "prob_asc"  %}selected{% endif %}>Lowest Prob</option>
+    </select>
+
+    <select name="page_size">
+      <option value="10"  {% if page_size == 10  %}selected{% endif %}>10 / page</option>
+      <option value="50"  {% if page_size == 50  %}selected{% endif %}>50 / page</option>
+      <option value="100" {% if page_size == 100 %}selected{% endif %}>100 / page</option>
+    </select>
+
+    <button type="submit">Filter</button>
+    {% if q or band or urgency or outcome or sort %}
+    <a href="{{ url_for('reports', page_size=page_size) }}" class="btn btn-ghost">Clear</a>
+    {% endif %}
+  </form>
+  <!-- prettier-ignore-end -->
+
+  <!-- Results meta bar -->
+  <div class="info-bar" style="margin-bottom: 14px">
+    <span>Filtered: <strong>{{ total_items }}</strong> of {{ total_cases }}</span>
+    <span>Page: <strong>{{ page }} / {{ total_pages }}</strong></span>
+    <span>Showing: <strong>{{ rows|length }}</strong> rows</span>
+    <span>{{ '%.1f'|format(route_compute_ms) }} ms</span>
+    <span>Cache: <strong>{{ 'HIT' if data_cache_hit else 'MISS' }}</strong></span>
+  </div>
+
+  <!-- Results table -->
+  <div class="table-wrap">
+    <table>
+      <thead>
+        <tr>
+          <th>#</th>
+          <th>Image ID</th>
+          <th>Date</th>
+          <th>Outcome</th>
+          <th>Cal. Prob</th>
+          <th>Band</th>
+          <th>Urgency</th>
+          <th>Grad-CAM</th>
+          <th>Report</th>
+        </tr>
+      </thead>
+      <tbody>
+        {% for row in rows %}
+        <tr class="{% if row.is_positive %}row-positive{% endif %}">
+          <td class="muted">{{ page_start + loop.index }}</td>
+          <td class="mono">{{ row.image_id }}</td>
+          <td class="muted small">{{ row.date_display }}</td>
+          <td>
+            {% if row.is_positive %}
+              <span class="dot dot-red"></span> Positive
+            {% else %}
+              <span class="dot dot-green"></span> Negative
+            {% endif %}
+          </td>
+          <td>{{ '%.4f'|format(row.cal_prob) if row.cal_prob is not none else '—' }}</td>
+          <td><span class="badge badge-{{ row.band|lower }}">{{ row.band }}</span></td>
+          <td><span class="badge badge-{{ row.urgency|lower }}">{{ row.urgency }}</span></td>
+          <td>
+            {% if row.gradcam_file %}
+            <a href="{{ url_for('serve_gradcam', filename=row.gradcam_file) }}"
+               target="_blank" class="link-icon" title="View Grad-CAM">
+              <svg width="16" height="16" viewBox="0 0 24 24" fill="none"
+                   stroke="currentColor" stroke-width="2">
+                <rect x="3" y="3" width="18" height="18" rx="2" />
+                <circle cx="8.5" cy="8.5" r="1.5" />
+                <path d="m21 15-5-5L5 21" />
+              </svg>
+            </a>
+            {% else %}
+            <span class="muted">—</span>
+            {% endif %}
+          </td>
+          <td>
+            <a href="{{ url_for('case_detail', image_id=row.image_id) }}" class="btn btn-sm">Open</a>
+          </td>
+        </tr>
+        {% endfor %}
+
+        {% if not rows %}
+        <tr>
+          <td colspan="9" class="muted" style="text-align: center; padding: 32px">
+            No cases match your filters.
+          </td>
+        </tr>
+        {% endif %}
+      </tbody>
+    </table>
+  </div>
+
+  <!-- Pagination -->
+  {% if total_pages > 1 %}
+  <div class="filters" style="justify-content: space-between; margin-top: 14px">
+    <div>
+      {% if page > 1 %}
+      <a class="btn" href="{{ url_for('reports', q=q, band=band, urgency=urgency, outcome=outcome, sort=sort, page=page-1, page_size=page_size) }}">← Previous</a>
+      {% else %}
+      <span class="btn btn-ghost" style="opacity: 0.5; pointer-events: none">← Previous</span>
+      {% endif %}
+    </div>
+    <div class="muted small" style="align-self: center">Page {{ page }} of {{ total_pages }}</div>
+    <div>
+      {% if page < total_pages %}
+      <a class="btn" href="{{ url_for('reports', q=q, band=band, urgency=urgency, outcome=outcome, sort=sort, page=page+1, page_size=page_size) }}">Next →</a>
+      {% else %}
+      <span class="btn btn-ghost" style="opacity: 0.5; pointer-events: none">Next →</span>
+      {% endif %}
+    </div>
+  </div>
+  {% endif %}
+</section>
+{% endblock %}
+

templates/upload.html

@@ -0,0 +1,331 @@
+{% extends "base.html" %}
+
+{% block title %}Upload Scan — ICH Screening{% endblock %}
+
+{% block content %}
+<section class="breadcrumb">
+  <a href="{{ url_for('home') }}">Home</a>
+  <span class="sep">/</span>
+  <span>Upload Scans</span>
+</section>
+
+<section class="upload-hero">
+  <h1>Upload DICOM Scans</h1>
+  <p>
+    Upload one or many CT brain scans for AI-powered hemorrhage screening.
+    A single exam may contain hundreds of slices — all modes below handle
+    that seamlessly.
+  </p>
+</section>
+
+{% with messages = get_flashed_messages(with_categories=true) %}
+{% if messages %}
+<div class="flash-messages">
+  {% for category, message in messages %}
+  <div class="flash flash-{{ category }}">{{ message }}</div>
+  {% endfor %}
+</div>
+{% endif %}
+{% endwith %}
+
+<!-- ── Tab navigation ──────────────────────────────────────────────── -->
+<div class="upload-tabs" role="tablist">
+  <button class="upload-tab active" data-tab="single"  role="tab">Single File</button>
+  <button class="upload-tab"        data-tab="multi"   role="tab">Multi-File / ZIP</button>
+  {% if local_mode %}
+  <button class="upload-tab"        data-tab="dirscan" role="tab">Scan Directory</button>
+  {% endif %}
+</div>
+
+<!-- ════════════════════════════════════════════════════════════════════ -->
+<!--  TAB 1 — Single .dcm file                                         -->
+<!-- ════════════════════════════════════════════════════════════════════ -->
+<section class="panel upload-panel tab-panel active" id="tab-single">
+  <form method="post" action="{{ url_for('analyze') }}"
+        enctype="multipart/form-data" id="singleForm">
+
+    <div class="dropzone" id="dropzoneSingle">
+      <svg width="56" height="56" viewBox="0 0 24 24" fill="none"
+           stroke="currentColor" stroke-width="1.5"
+           stroke-linecap="round" stroke-linejoin="round">
+        <path d="M21 15v4a2 2 0 0 1-2 2H5a2 2 0 0 1-2-2v-4" />
+        <polyline points="17 8 12 3 7 8" />
+        <line x1="12" y1="3" x2="12" y2="15" />
+      </svg>
+      <p class="dropzone-text">Drag &amp; drop a .dcm file here</p>
+      <p class="muted small">or click to browse</p>
+      <input type="file" name="file" id="singleInput" accept=".dcm" hidden />
+    </div>
+
+    <div class="file-info" id="singleInfo" style="display: none">
+      <svg width="20" height="20" viewBox="0 0 24 24" fill="none"
+           stroke="currentColor" stroke-width="2">
+        <path d="M14 2H6a2 2 0 0 0-2 2v16a2 2 0 0 0 2 2h12a2 2 0 0 0 2-2V8z" />
+        <polyline points="14 2 14 8 20 8" />
+      </svg>
+      <span id="singleFileName"></span>
+      <button type="button" class="btn btn-sm btn-ghost js-clear-single">Remove</button>
+    </div>
+
+    <button type="submit" class="btn btn-primary" id="singleSubmit" disabled>
+      <svg width="16" height="16" viewBox="0 0 24 24" fill="none"
+           stroke="currentColor" stroke-width="2">
+        <path d="M22 12h-4l-3 9L9 3l-3 9H2" />
+      </svg>
+      Analyze Scan
+    </button>
+  </form>
+
+  <div class="loading-overlay" id="singleOverlay" style="display: none">
+    <div class="spinner"></div>
+    <p>Running AI analysis&hellip;</p>
+    <p class="muted small">This may take a moment on first run while the model loads.</p>
+  </div>
+</section>
+
+<!-- ════════════════════════════════════════════════════════════════════ -->
+<!--  TAB 2 — Multi-file / ZIP upload                                   -->
+<!-- ════════════════════════════════════════════════════════════════════ -->
+<section class="panel upload-panel tab-panel" id="tab-multi">
+  <form method="post" action="{{ url_for('analyze') }}"
+        enctype="multipart/form-data" id="multiForm">
+
+    <div class="dropzone" id="dropzoneMulti">
+      <svg width="56" height="56" viewBox="0 0 24 24" fill="none"
+           stroke="currentColor" stroke-width="1.5"
+           stroke-linecap="round" stroke-linejoin="round">
+        <rect x="2" y="7" width="20" height="14" rx="2" />
+        <path d="M16 7V5a2 2 0 0 0-2-2h-4a2 2 0 0 0-2 2v2" />
+      </svg>
+      <p class="dropzone-text">Drag &amp; drop .dcm files or a .zip archive</p>
+      <p class="muted small">Select multiple files, or a single .zip containing DICOM slices</p>
+      <input type="file" name="file" id="multiInput"
+             accept=".dcm,.zip" multiple hidden />
+    </div>
+
+    <div class="file-info" id="multiInfo" style="display: none">
+      <svg width="20" height="20" viewBox="0 0 24 24" fill="none"
+           stroke="currentColor" stroke-width="2">
+        <rect x="2" y="7" width="20" height="14" rx="2" />
+        <path d="M16 7V5a2 2 0 0 0-2-2h-4a2 2 0 0 0-2 2v2" />
+      </svg>
+      <span id="multiFileName"></span>
+      <button type="button" class="btn btn-sm btn-ghost js-clear-multi">Remove all</button>
+    </div>
+
+    <button type="submit" class="btn btn-primary" id="multiSubmit" disabled>
+      <svg width="16" height="16" viewBox="0 0 24 24" fill="none"
+           stroke="currentColor" stroke-width="2">
+        <path d="M22 12h-4l-3 9L9 3l-3 9H2" />
+      </svg>
+      Analyze Batch
+    </button>
+  </form>
+
+  <div class="loading-overlay" id="multiOverlay" style="display: none">
+    <div class="spinner"></div>
+    <p>Uploading files&hellip;</p>
+    <p class="muted small">Large batches may take a moment to upload.</p>
+  </div>
+</section>
+
+<!-- ════════════════════════════════════════════════════════════════════ -->
+<!--  TAB 3 — Directory scan (local mode only)                          -->
+<!-- ════════════════════════════════════════════════════════════════════ -->
+{% if local_mode %}
+<section class="panel upload-panel tab-panel" id="tab-dirscan">
+  <form method="post" action="{{ url_for('analyze_directory') }}" id="dirForm">
+    <label class="dir-label" for="dirPath">
+      Server-side directory containing .dcm files
+    </label>
+    <div class="dir-input-row">
+      <input type="text" name="dir_path" id="dirPath" class="input"
+             placeholder="D:\scans\patient_001"
+             spellcheck="false" autocomplete="off" />
+      <button type="submit" class="btn btn-primary" id="dirSubmit">
+        <svg width="16" height="16" viewBox="0 0 24 24" fill="none"
+             stroke="currentColor" stroke-width="2">
+          <circle cx="11" cy="11" r="8" />
+          <line x1="21" y1="21" x2="16.65" y2="16.65" />
+        </svg>
+        Scan &amp; Analyze
+      </button>
+    </div>
+    <p class="muted small" style="margin-top: 8px">
+      The server will recursively find all <code>.dcm</code> files in this
+      directory and its sub-folders, then run inference on each.
+      This option is only available when running locally.
+    </p>
+  </form>
+</section>
+{% endif %}
+
+<!-- ── How it works ────────────────────────────────────────────────── -->
+<section class="panel" style="margin-top: 16px">
+  <h3>How It Works</h3>
+  <div class="steps-grid">
+    <div class="step">
+      <div class="step-num">1</div>
+      <div class="step-text">
+        <strong>Upload</strong>
+        <p class="muted small">Select DICOM files, a ZIP, or enter a directory path</p>
+      </div>
+    </div>
+    <div class="step">
+      <div class="step-num">2</div>
+      <div class="step-text">
+        <strong>Process</strong>
+        <p class="muted small">CT windowing &amp; preprocessing on each slice</p>
+      </div>
+    </div>
+    <div class="step">
+      <div class="step-num">3</div>
+      <div class="step-text">
+        <strong>Analyze</strong>
+        <p class="muted small">EfficientNet-B0 model with calibrated scoring</p>
+      </div>
+    </div>
+    <div class="step">
+      <div class="step-num">4</div>
+      <div class="step-text">
+        <strong>Report</strong>
+        <p class="muted small">Grad-CAM visualization &amp; clinical report per slice</p>
+      </div>
+    </div>
+  </div>
+</section>
+{% endblock %}
+
+{% block scripts %}
+<script>
+(function () {
+  /* ── Tab switching ────────────────────────────────────────────────── */
+  var tabs   = document.querySelectorAll(".upload-tab");
+  var panels = document.querySelectorAll(".tab-panel");
+
+  tabs.forEach(function (tab) {
+    tab.addEventListener("click", function () {
+      tabs.forEach(function (t) { t.classList.remove("active"); });
+      panels.forEach(function (p) { p.classList.remove("active"); });
+      tab.classList.add("active");
+      var target = document.getElementById("tab-" + tab.dataset.tab);
+      if (target) target.classList.add("active");
+    });
+  });
+
+  /* ── Helper: generic dropzone wiring ─────────────────────────────── */
+  function wireDropzone(opts) {
+    var zone    = document.getElementById(opts.zoneId);
+    var input   = document.getElementById(opts.inputId);
+    var info    = document.getElementById(opts.infoId);
+    var label   = document.getElementById(opts.labelId);
+    var clear   = document.querySelector(opts.clearSel);
+    var submit  = document.getElementById(opts.submitId);
+    var form    = document.getElementById(opts.formId);
+    var overlay = document.getElementById(opts.overlayId);
+
+    if (!zone || !input) return;
+
+    function showFiles(files) {
+      var validFiles = [];
+      for (var i = 0; i < files.length; i++) {
+        var name = files[i].name.toLowerCase();
+        if (name.endsWith(".dcm") || name.endsWith(".zip")) {
+          validFiles.push(files[i]);
+        }
+      }
+      if (!validFiles.length) return;
+
+      if (opts.multi) {
+        var totalSizeMB = 0;
+        for (var j = 0; j < validFiles.length; j++) {
+          totalSizeMB += validFiles[j].size / (1024 * 1024);
+        }
+        label.textContent = validFiles.length + " file" +
+          (validFiles.length > 1 ? "s" : "") +
+          " (" + totalSizeMB.toFixed(1) + " MB)";
+      } else {
+        label.textContent = validFiles[0].name;
+      }
+
+      info.style.display  = "flex";
+      zone.style.display  = "none";
+      submit.disabled     = false;
+    }
+
+    function reset() {
+      input.value         = "";
+      info.style.display  = "none";
+      zone.style.display  = "flex";
+      submit.disabled     = true;
+    }
+
+    zone.addEventListener("click", function () { input.click(); });
+
+    zone.addEventListener("dragover", function (e) {
+      e.preventDefault();
+      zone.classList.add("dragover");
+    });
+    zone.addEventListener("dragleave", function () {
+      zone.classList.remove("dragover");
+    });
+    zone.addEventListener("drop", function (e) {
+      e.preventDefault();
+      zone.classList.remove("dragover");
+      if (e.dataTransfer.files.length) {
+        input.files = e.dataTransfer.files;
+        showFiles(e.dataTransfer.files);
+      }
+    });
+
+    input.addEventListener("change", function () {
+      if (input.files.length) showFiles(input.files);
+    });
+
+    if (clear) clear.addEventListener("click", reset);
+
+    if (form && overlay) {
+      form.addEventListener("submit", function () {
+        overlay.style.display = "flex";
+        submit.disabled = true;
+      });
+    }
+  }
+
+  /* ── Wire single-file dropzone ───────────────────────────────────── */
+  wireDropzone({
+    zoneId:    "dropzoneSingle",
+    inputId:   "singleInput",
+    infoId:    "singleInfo",
+    labelId:   "singleFileName",
+    clearSel:  ".js-clear-single",
+    submitId:  "singleSubmit",
+    formId:    "singleForm",
+    overlayId: "singleOverlay",
+    multi:     false,
+  });
+
+  /* ── Wire multi-file dropzone ────────────────────────────────────── */
+  wireDropzone({
+    zoneId:    "dropzoneMulti",
+    inputId:   "multiInput",
+    infoId:    "multiInfo",
+    labelId:   "multiFileName",
+    clearSel:  ".js-clear-multi",
+    submitId:  "multiSubmit",
+    formId:    "multiForm",
+    overlayId: "multiOverlay",
+    multi:     true,
+  });
+
+  /* ── Directory scan: disable submit when input is empty ──────────── */
+  var dirInput  = document.getElementById("dirPath");
+  var dirSubmit = document.getElementById("dirSubmit");
+  if (dirInput && dirSubmit) {
+    function checkDir() { dirSubmit.disabled = !dirInput.value.trim(); }
+    dirInput.addEventListener("input", checkDir);
+    checkDir();
+  }
+})();
+</script>
+{% endblock %}