Deploy DDA jobs API, hierarchy panel, and region locate on dev.

Async job queue with sync fallback for Run Detection; zone/village tree in library sidebar; click-to-locate regions in result viewer.

Co-authored-by: Cursor <cursoragent@cursor.com>

Dockerfile

@@ -21,7 +21,7 @@ WORKDIR /app
 
 # Build-time info + cache-bust:
 # Changing APP_BUILD forces Docker to re-run subsequent layers (including pip install).
-ARG APP_BUILD=32
+ARG APP_BUILD=33
 ENV MAX_GEOTIFF_MB=5120
 ENV APP_BUILD=${APP_BUILD}
 ENV GDAL_CONFIG=/usr/bin/gdal-config

app/dda/bootstrap.py

@@ -5,6 +5,7 @@ from sqlalchemy import text as sa_text
 
 from ..database import engine
 from .config import IS_DDA_MODE, ensure_library_dirs, ensure_local_year_folders, is_hf_hosted
+from .jobs_routes import router as jobs_router
 from .library_routes import router as library_router
 from .local_routes import router as local_router
 from .seed import seed_delhi_hierarchy
@@ -53,5 +54,6 @@ def setup_dda(app: FastAPI) -> None:
         logger.info("APP_MODE=legacy — DDA routes disabled")
         return
     app.include_router(library_router, prefix="/api/dda", tags=["dda"])
+    app.include_router(jobs_router, prefix="/api/dda", tags=["dda-jobs"])
     app.include_router(local_router, prefix="/api/dda", tags=["dda-local"])
-    logger.info("APP_MODE=dda — DDA routes enabled (local folder library + legacy upload API)")
+    logger.info("APP_MODE=dda — DDA routes enabled (library, jobs, local folder)")

app/dda/job_runner.py

@@ -0,0 +1,210 @@
+"""Background detection job runner (FR-04 async pipeline)."""
+from __future__ import annotations
+
+import json
+import logging
+import threading
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+from PIL import Image
+from sqlalchemy.orm import Session
+
+from ..auth import get_or_create_guest_user
+from ..database import SessionLocal
+from ..models import DetectionRun
+from .config import get_detection_max_side
+from .detect_service import run_detection_and_save
+from .geotiff_io import load_rgb_pil
+from .local_library import safe_resolve
+from .models import DetectionJob
+
+logger = logging.getLogger(__name__)
+
+_runner_lock = threading.Lock()
+_active_job_id: Optional[int] = None
+
+
+def _utcnow():
+    return datetime.now(timezone.utc)
+
+
+def _load_pair(base_path: str, comparison_path: str) -> tuple[Image.Image, Image.Image, Path]:
+    base_file = safe_resolve(base_path)
+    comp_file = safe_resolve(comparison_path)
+    max_side = get_detection_max_side()
+    before_pil = load_rgb_pil(base_file, max_side=max_side)
+    after_pil = load_rgb_pil(comp_file, max_side=max_side)
+    if before_pil.size != after_pil.size:
+        after_pil = after_pil.resize(before_pil.size, Image.Resampling.LANCZOS)
+    return before_pil, after_pil, base_file
+
+
+def _parse_params(job: DetectionJob) -> Dict[str, Any]:
+    try:
+        return json.loads(job.params_json or "{}")
+    except json.JSONDecodeError:
+        return {}
+
+
+def _run_job_sync(job_id: int) -> None:
+    global _active_job_id
+    db = SessionLocal()
+    try:
+        job = db.query(DetectionJob).filter(DetectionJob.id == job_id).first()
+        if not job or job.status not in ("queued", "running"):
+            return
+
+        job.status = "running"
+        job.started_at = _utcnow()
+        job.error_message = ""
+        db.commit()
+
+        params = _parse_params(job)
+        base_path = params.get("base_path", "")
+        comparison_path = params.get("comparison_path", "")
+        if not base_path or not comparison_path:
+            raise ValueError("Job missing base_path or comparison_path in params_json")
+
+        before_pil, after_pil, base_file = _load_pair(base_path, comparison_path)
+        title = params.get("title") or f"{Path(base_path).name} vs {Path(comparison_path).name}"
+        result = run_detection_and_save(
+            db,
+            before_pil,
+            after_pil,
+            method=job.method or params.get("method", "AI-Based Deep Learning"),
+            title=title,
+            zone=params.get("zone", ""),
+            village=params.get("village", ""),
+            enable_registration=bool(params.get("enable_registration", True)),
+            enable_normalization=bool(params.get("enable_normalization", True)),
+            detection_sensitivity=float(params.get("detection_sensitivity", 0.45)),
+            min_region_area=params.get("min_region_area"),
+            notify_email=job.notify_email or params.get("notify_email"),
+            max_size=get_detection_max_side(),
+            geo_bounds_path=base_file,
+        )
+
+        job.status = "completed"
+        job.run_id = result["id"]
+        job.completed_at = _utcnow()
+        db.commit()
+        logger.info("Detection job %d completed → run %s", job_id, result["id"])
+    except Exception as exc:
+        logger.exception("Detection job %d failed", job_id)
+        try:
+            job = db.query(DetectionJob).filter(DetectionJob.id == job_id).first()
+            if job:
+                job.status = "failed"
+                job.error_message = str(exc)[:2000]
+                job.completed_at = _utcnow()
+                db.commit()
+        except Exception:
+            db.rollback()
+    finally:
+        with _runner_lock:
+            if _active_job_id == job_id:
+                _active_job_id = None
+        db.close()
+
+
+def _job_worker(job_id: int) -> None:
+    global _active_job_id
+    with _runner_lock:
+        _active_job_id = job_id
+    try:
+        _run_job_sync(job_id)
+    finally:
+        with _runner_lock:
+            if _active_job_id == job_id:
+                _active_job_id = None
+
+
+def enqueue_detection_job(job_id: int) -> bool:
+    """Start job in a background thread. Returns False if another job is running."""
+    global _active_job_id
+    with _runner_lock:
+        if _active_job_id is not None:
+            return False
+        _active_job_id = job_id
+    thread = threading.Thread(target=_job_worker, args=(job_id,), daemon=True, name=f"dda-job-{job_id}")
+    thread.start()
+    return True
+
+
+def is_job_runner_busy() -> bool:
+    with _runner_lock:
+        return _active_job_id is not None
+
+
+def create_local_folder_job(
+    db: Session,
+    *,
+    base_path: str,
+    comparison_path: str,
+    method: str = "AI-Based Deep Learning",
+    title: str = "",
+    zone: str = "",
+    village: str = "",
+    enable_registration: bool = True,
+    enable_normalization: bool = True,
+    detection_sensitivity: float = 0.45,
+    min_region_area: Optional[int] = 150,
+    notify_email: str = "",
+    created_by: Optional[int] = None,
+) -> DetectionJob:
+    user = get_or_create_guest_user(db)
+    params = {
+        "source": "local_folder",
+        "base_path": base_path.replace("\\", "/"),
+        "comparison_path": comparison_path.replace("\\", "/"),
+        "method": method,
+        "title": title,
+        "zone": zone,
+        "village": village,
+        "enable_registration": enable_registration,
+        "enable_normalization": enable_normalization,
+        "detection_sensitivity": detection_sensitivity,
+        "min_region_area": min_region_area,
+    }
+    job = DetectionJob(
+        status="queued",
+        base_image_id=None,
+        comparison_image_id=None,
+        method=method,
+        params_json=json.dumps(params),
+        notify_email=notify_email or "",
+        created_by=created_by or user.id,
+    )
+    db.add(job)
+    db.commit()
+    db.refresh(job)
+    return job
+
+
+def job_to_dict(job: DetectionJob, run: Optional[DetectionRun] = None) -> dict:
+    params = _parse_params(job)
+    out = {
+        "id": job.id,
+        "status": job.status,
+        "method": job.method,
+        "basePath": params.get("base_path", ""),
+        "comparisonPath": params.get("comparison_path", ""),
+        "title": params.get("title", ""),
+        "runId": job.run_id,
+        "errorMessage": job.error_message or "",
+        "notifyEmail": job.notify_email or "",
+        "createdAt": job.created_at.isoformat() if job.created_at else None,
+        "startedAt": job.started_at.isoformat() if job.started_at else None,
+        "completedAt": job.completed_at.isoformat() if job.completed_at else None,
+    }
+    if run:
+        out["report"] = {
+            "id": run.id,
+            "title": run.title,
+            "changePercentage": run.change_percentage,
+            "regionsCount": run.regions_count,
+            "overlayUrl": f"/api/overlay/{run.overlay_path}" if run.overlay_path else None,
+        }
+    return out

app/dda/jobs_routes.py

@@ -0,0 +1,182 @@
+"""Async detection job API (FR-04)."""
+from __future__ import annotations
+
+import json
+import logging
+from typing import Optional
+
+from fastapi import APIRouter, Depends, Form, HTTPException, Query
+from sqlalchemy.orm import Session
+
+from ..auth import get_or_create_guest_user
+from ..database import get_db
+from ..models import DetectionRun
+from .job_runner import (
+    create_local_folder_job,
+    enqueue_detection_job,
+    is_job_runner_busy,
+    job_to_dict,
+)
+from .local_library import safe_resolve
+from .models import DetectionJob
+
+logger = logging.getLogger(__name__)
+router = APIRouter()
+
+
+def _require_dda():
+    from .config import IS_DDA_MODE
+    if not IS_DDA_MODE:
+        raise HTTPException(status_code=404, detail="DDA mode is not enabled")
+
+
+@router.post("/jobs")
+async def create_job(
+    base_path: str = Form(...),
+    comparison_path: str = Form(...),
+    method: str = Form("AI-Based Deep Learning"),
+    title: str = Form(""),
+    zone: str = Form(""),
+    village: str = Form(""),
+    enable_registration: bool = Form(True),
+    enable_normalization: bool = Form(True),
+    detection_sensitivity: float = Form(0.45),
+    min_region_area: Optional[int] = Form(150),
+    notify_email: Optional[str] = Form(None),
+    db: Session = Depends(get_db),
+):
+    """Queue async detection from local library paths. Returns immediately with jobId."""
+    _require_dda()
+    base_norm = base_path.replace("\\", "/").strip()
+    comp_norm = comparison_path.replace("\\", "/").strip()
+    if not base_norm or not comp_norm:
+        raise HTTPException(status_code=400, detail="base_path and comparison_path are required")
+    if base_norm == comp_norm:
+        raise HTTPException(status_code=400, detail="Base and comparison images must be different")
+
+    try:
+        safe_resolve(base_norm)
+        safe_resolve(comp_norm)
+    except HTTPException:
+        raise
+    except Exception as exc:
+        raise HTTPException(status_code=400, detail=f"Invalid library path: {exc}") from exc
+
+    if is_job_runner_busy():
+        raise HTTPException(
+            status_code=409,
+            detail="Another detection job is already running. Wait for it to finish, then try again.",
+        )
+
+    user = get_or_create_guest_user(db)
+    if not title.strip():
+        from pathlib import Path
+        title = f"{Path(base_norm).name} vs {Path(comp_norm).name}"
+
+    job = create_local_folder_job(
+        db,
+        base_path=base_norm,
+        comparison_path=comp_norm,
+        method=method,
+        title=title,
+        zone=zone,
+        village=village,
+        enable_registration=enable_registration,
+        enable_normalization=enable_normalization,
+        detection_sensitivity=detection_sensitivity,
+        min_region_area=min_region_area,
+        notify_email=notify_email or "",
+        created_by=user.id,
+    )
+
+    if not enqueue_detection_job(job.id):
+        job.status = "failed"
+        job.error_message = "Could not start background worker"
+        db.commit()
+        raise HTTPException(status_code=503, detail="Job queue is busy")
+
+    return {"jobId": job.id, "status": "queued", "message": "Detection job queued. Poll GET /api/dda/jobs/{id} for status."}
+
+
+@router.get("/jobs/{job_id}")
+def get_job(job_id: int, db: Session = Depends(get_db)):
+    _require_dda()
+    user = get_or_create_guest_user(db)
+    job = db.query(DetectionJob).filter(DetectionJob.id == job_id).first()
+    if not job:
+        raise HTTPException(status_code=404, detail="Job not found")
+    if job.created_by and job.created_by != user.id:
+        raise HTTPException(status_code=403, detail="Not allowed to view this job")
+
+    run = None
+    if job.run_id:
+        run = db.query(DetectionRun).filter(DetectionRun.id == job.run_id).first()
+
+    data = job_to_dict(job, run=run)
+    if job.status == "completed" and run:
+        try:
+            data["result"] = _run_detail(db, run, user.id)
+        except HTTPException:
+            raise
+        except Exception as exc:
+            logger.warning("Could not load full run for job %s: %s", job_id, exc)
+    return data
+
+
+def _run_detail(db: Session, run: DetectionRun, user_id: int) -> dict:
+    import base64
+
+    from ..database import DATA_DIR
+
+    if run.user_id != user_id:
+        raise HTTPException(status_code=403, detail="Not allowed")
+
+    regions = json.loads(run.regions_json or "[]")
+    overlay_b64 = ""
+    if run.overlay_path:
+        overlay_file = DATA_DIR / run.overlay_path
+        if overlay_file.exists():
+            overlay_b64 = base64.b64encode(overlay_file.read_bytes()).decode("utf-8")
+
+    from .detect_service import _isoformat_ist
+
+    return {
+        "id": run.id,
+        "title": run.title,
+        "method": run.method,
+        "zone": run.zone or "",
+        "village": run.village or "",
+        "statistics": {
+            "totalPixels": run.total_pixels,
+            "changedPixels": run.changed_pixels,
+            "unchangedPixels": run.total_pixels - run.changed_pixels,
+            "changePercentage": run.change_percentage,
+        },
+        "regions": regions,
+        "overlayBase64Png": overlay_b64,
+        "overlayUrl": f"/api/overlay/{run.overlay_path}" if run.overlay_path else None,
+        "beforeFullUrl": f"/api/overlay/{run.before_full_path}" if run.before_full_path else None,
+        "beforeThumbUrl": f"/api/overlay/{run.before_thumb_path}" if run.before_thumb_path else None,
+        "afterThumbUrl": f"/api/overlay/{run.after_thumb_path}" if run.after_thumb_path else None,
+        "createdAt": _isoformat_ist(run.created_at),
+    }
+
+
+@router.get("/jobs")
+def list_jobs(
+    status: Optional[str] = Query(None),
+    limit: int = Query(20, ge=1, le=100),
+    db: Session = Depends(get_db),
+):
+    """Recent detection jobs for in-app notifications / reports feed (FR-05 partial)."""
+    _require_dda()
+    user = get_or_create_guest_user(db)
+    q = db.query(DetectionJob).filter(DetectionJob.created_by == user.id)
+    if status:
+        q = q.filter(DetectionJob.status == status)
+    jobs = q.order_by(DetectionJob.created_at.desc()).limit(limit).all()
+    out = []
+    for job in jobs:
+        run = db.query(DetectionRun).filter(DetectionRun.id == job.run_id).first() if job.run_id else None
+        out.append(job_to_dict(job, run=run))
+    return {"jobs": out, "runnerBusy": is_job_runner_busy()}

app/dda/models.py

@@ -77,8 +77,8 @@ class DetectionJob(Base):
 
     id = Column(Integer, primary_key=True, index=True)
     status = Column(String(32), default="queued", index=True)  # queued|running|completed|failed
-    base_image_id = Column(Integer, ForeignKey("dda_image_assets.id"), nullable=False)
-    comparison_image_id = Column(Integer, ForeignKey("dda_image_assets.id"), nullable=False)
+    base_image_id = Column(Integer, ForeignKey("dda_image_assets.id"), nullable=True)
+    comparison_image_id = Column(Integer, ForeignKey("dda_image_assets.id"), nullable=True)
     method = Column(String(64), default="AI-Based Deep Learning")
     params_json = Column(Text, default="{}")
     run_id = Column(Integer, ForeignKey("detection_runs.id"), nullable=True)

app/detection_engine.py

@@ -20,6 +20,18 @@ _log = logging.getLogger(__name__)
 # 1. Pre-processing
 # ---------------------------------------------------------------------------
 
+def get_detection_max_size() -> int:
+    """Max pixel dimension for detection (override with DETECTION_MAX_SIDE env)."""
+    import os
+    hosted = bool(os.environ.get("SPACE_ID", "").strip())
+    default = "2048" if hosted else "4096"
+    try:
+        value = int(os.environ.get("DETECTION_MAX_SIDE", default))
+    except ValueError:
+        value = int(default)
+    return max(1024, min(8192, value))
+
+
 def _ensure_rgb_uint8(img_array):
     """Convert any image array to 3-channel RGB uint8."""
     if img_array.ndim == 2:
@@ -38,8 +50,10 @@ def _to_float32(img):
     return img.astype(np.float32) / 255.0
 
 
-def preprocess_image(image, max_size=1600):
-    """Preprocess image: convert to RGB, limit size, light Gaussian denoise."""
+def preprocess_image(image, max_size=None):
+    """Preprocess image: convert to RGB, limit size, light denoise."""
+    if max_size is None:
+        max_size = get_detection_max_size()
     img_array = np.array(image)
     img_array = _ensure_rgb_uint8(img_array)
 
@@ -49,10 +63,12 @@ def preprocess_image(image, max_size=1600):
         new_w, new_h = max(1, int(width * scale)), max(1, int(height * scale))
         img_array = cv2.resize(img_array, (new_w, new_h), interpolation=cv2.INTER_AREA)
 
-    img_array = cv2.GaussianBlur(img_array, (5, 5), 0)
+    # Light denoise — smaller kernel preserves fine change detail at high resolution
+    blur_ksize = 3 if max_size >= 3000 else 5
+    img_array = cv2.GaussianBlur(img_array, (blur_ksize, blur_ksize), 0)
     gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
     lap_var = float(cv2.Laplacian(gray, cv2.CV_64F).var())
-    if lap_var < 80.0:
+    if lap_var < 60.0:
         img_array = cv2.bilateralFilter(img_array, 5, 50, 50)
     return img_array
 
@@ -774,7 +790,8 @@ def _ai_fusion_core(img1, img2, sensitivity=0.5, registration_ok=True):
         img1, img2, registration_ok=registration_ok)
 
     sens = float(np.clip(sensitivity, 0.0, 1.0))
-    q = float(np.clip(0.96 - (sens - 0.5) * 0.04, 0.92, 0.98))
+    # Looser percentile than gated fusion — keeps recall for multi-region detection
+    q = float(np.clip(0.93 - (sens - 0.5) * 0.06, 0.85, 0.96))
     thr_score = float(np.quantile(classical_score, q))
     change_mask = (classical_score >= thr_score).astype(np.uint8) * 255
     change_mask = _clean_mask(change_mask, sensitivity=sens)
@@ -796,40 +813,134 @@ def _ai_fusion_core(img1, img2, sensitivity=0.5, registration_ok=True):
     return change_mask, classical_score, debug
 
 
+def _smart_union_fusion(model_mask, rule_mask, dl_score, classical_score, sensitivity=0.5):
+    """
+    Union with confidence pruning: keep pixels where at least one engine is
+    confident, or both agree. Drops weak single-engine speckle (hallucinations).
+    """
+    sens = float(np.clip(sensitivity, 0.0, 1.0))
+    model_on = model_mask > 127
+    rule_on = rule_mask > 127
+    both_agree = model_on & rule_on
+
+    dl_floor = 0.32 + (1.0 - sens) * 0.10
+    cl_q = float(np.clip(0.91 - (sens - 0.5) * 0.03, 0.87, 0.94))
+    cl_floor = (
+        float(np.quantile(classical_score, cl_q))
+        if float(classical_score.max()) > 1e-6 else 0.38
+    )
+
+    dl_ok = dl_score >= dl_floor
+    cl_ok = classical_score >= cl_floor
+    keep = both_agree | (model_on & dl_ok) | (rule_on & cl_ok)
+    return np.where(keep, 255, 0).astype(np.uint8)
+
+
+def _structural_evidence(diff, feat_a):
+    """Score how strongly a region looks like built structure (not water/vegetation)."""
+    score = 0.0
+    if diff:
+        if diff.get("delta_lines", 0) > 2:
+            score += 0.28
+        if diff.get("delta_corners", 0) > 3:
+            score += 0.24
+        if diff.get("delta_edge_density", 0) > 8:
+            score += 0.20
+        if diff.get("hull_ratio_after", 0) > 0.35:
+            score += 0.18
+        if diff.get("lines_after", 0) > 4:
+            score += 0.14
+        if diff.get("ssim", 1.0) < 0.65:
+            score += 0.12
+    if feat_a.get("edge_density", 0) > 35:
+        score += 0.18
+    if feat_a.get("orientation_entropy", 3.0) < 2.4:
+        score += 0.14
+    return min(1.0, score)
+
+
+def _resolve_classification(scores, diff, feat_a):
+    """Apply cross-type constraints; fix water vs construction confusion."""
+    structural = _structural_evidence(diff, feat_a)
+
+    water = scores.get("Water Body Change", 0.0)
+    bld = scores.get("New Construction/Building", 0.0)
+
+    # Water needs smooth, blue, low-edge surface — not just one cue
+    water_cues = sum([
+        feat_a["blue_ratio"] > 0.38,
+        feat_a["edge_density"] < 28,
+        feat_a["texture_std"] < 26,
+        95 <= feat_a["hue"] <= 130,
+        feat_a["lbp_variance"] < 0.045,
+    ])
+    if water_cues < 3:
+        scores["Water Body Change"] = water * 0.45
+    elif water_cues < 4:
+        scores["Water Body Change"] = water * 0.75
+
+    # Built structure strongly disqualifies water
+    if structural >= 0.30:
+        scores["Water Body Change"] *= max(0.1, 1.0 - structural * 1.2)
+        scores["New Construction/Building"] = min(1.0, bld + structural * 0.45)
+
+    best = max(scores, key=scores.get)
+    conf = scores[best]
+
+    # Prefer construction when structural evidence is strong and scores are close
+    if (
+        best == "Water Body Change"
+        and scores["New Construction/Building"] >= conf * 0.72
+        and structural >= 0.22
+    ):
+        best = "New Construction/Building"
+        conf = scores["New Construction/Building"]
+
+    return best, conf
+
+
 def ai_deep_learning_method(img1, img2, sensitivity=0.5, registration_ok=True):
-    """AdaptFormer + confidence-gated classical fusion (no blind union)."""
+    """
+    Dual-engine: AdaptFormer + classical fusion with confidence-pruned union.
+    """
     from .model_inference import is_model_available, predict_change_mask
 
+    model_mask = None
     dl_score = None
     model_ok = False
-    T_dl = 0.40 + (1.0 - float(np.clip(sensitivity, 0, 1))) * 0.25
+    threshold = 0.30 + (1.0 - float(np.clip(sensitivity, 0, 1))) * 0.22
 
     if is_model_available():
         try:
-            _, dl_score = predict_change_mask(img1, img2, threshold=2.0)
+            model_mask, dl_score = predict_change_mask(img1, img2, threshold=threshold)
             model_ok = dl_score is not None
         except Exception as e:
             _log.warning("AdaptFormer inference failed: %s", e)
 
-    classical_score, _ = _compute_classical_score_map(
-        img1, img2, registration_ok=registration_ok)
+    rule_mask, classical_score, core_debug = _ai_fusion_core(
+        img1, img2, sensitivity=sensitivity, registration_ok=registration_ok)
 
     if model_ok and dl_score is not None:
-        combined, _, fuse_debug = fuse_dl_and_classical(
-            dl_score, classical_score, img1, img2, sensitivity=sensitivity)
+        if model_mask is None:
+            model_mask = (dl_score >= threshold).astype(np.uint8) * 255
+        combined = _smart_union_fusion(
+            model_mask, rule_mask, dl_score, classical_score, sensitivity=sensitivity)
+        combined = _clean_mask(combined, sensitivity=sensitivity)
         debug = {
-            "method": "AI-Based Deep Learning (AdaptFormer + gated fusion)",
+            "method": "AI-Based Deep Learning (AdaptFormer + confidence union)",
             "model": "adaptformer-levir-cd",
-            "threshold_used": int(T_dl * 255),
+            "fusion": "smart_union",
+            "threshold_used": int(threshold * 255),
             "sensitivity": float(sensitivity),
-            **fuse_debug,
+            "model_changed_px": int(np.sum(model_mask > 127)),
+            "rule_changed_px": int(np.sum(rule_mask > 127)),
+            "combined_changed_px": int(np.sum(combined > 127)),
         }
         return combined, debug
 
-    rule_mask, _, core_debug = _ai_fusion_core(
-        img1, img2, sensitivity=sensitivity, registration_ok=registration_ok)
     debug = {
         "method": "AI-Based Deep Learning (classical fallback)",
+        "threshold_used": core_debug.get("threshold_used"),
         "sensitivity": float(sensitivity),
         "core": core_debug,
     }
@@ -852,9 +963,9 @@ def hybrid_method(img1, img2, sensitivity=0.5, registration_ok=True):
         0.5 * ai_mask.astype(np.float32)
     )
 
-    base_thr = 110
+    base_thr = 98
     sens = float(np.clip(sensitivity, 0.0, 1.0))
-    hybrid_thr = int(np.clip(base_thr + int((0.5 - sens) * 36), 70, 160))
+    hybrid_thr = int(np.clip(base_thr + int((0.5 - sens) * 36), 60, 150))
     _, final_mask = cv2.threshold(combined.astype(np.uint8), hybrid_thr, 255, cv2.THRESH_BINARY)
     final_mask = _clean_mask(final_mask, sensitivity=sensitivity)
     debug = {
@@ -901,49 +1012,73 @@ def _build_confidence_map_from_channels(img1, img2, dl_score=None):
     return build_confidence_map(channels, weights)
 
 
+def _multiscale_classical(img1, img2, sensitivity=0.5, registration_ok=True):
+    """Run classical fusion at multiple scales and OR-combine for better recall."""
+    from .cd_models.model_utils import multiscale_detect
+
+    def _single_scale_detect(s1, s2):
+        mask, _, _ = _ai_fusion_core(
+            s1, s2, sensitivity=sensitivity, registration_ok=registration_ok)
+        return mask
+
+    return multiscale_detect(_single_scale_detect, img1, img2, scales=(1.0, 0.5))
+
+
 def hybrid_ai_method(img1, img2, sensitivity=0.5, registration_ok=True):
-    """Hybrid AI: same confidence-gated fusion as default AI path."""
+    """Hybrid AI: DL mask + multi-scale classical mask with confidence weighting."""
     if img1.shape != img2.shape:
         img2 = cv2.resize(img2, (img1.shape[1], img1.shape[0]))
 
     from .model_inference import is_model_available, predict_change_mask
 
-    dl_score = None
+    dl_mask = np.zeros(img1.shape[:2], dtype=np.uint8)
+    dl_score = np.zeros(img1.shape[:2], dtype=np.float32)
     dl_method = "none"
+    thr = 0.25 + (1.0 - float(np.clip(sensitivity, 0, 1))) * 0.25
 
     if is_model_available():
         try:
-            _, dl_score = predict_change_mask(img1, img2, threshold=2.0)
+            dl_mask, dl_score = predict_change_mask(img1, img2, threshold=thr)
             dl_method = "adaptformer"
         except Exception:
             pass
 
     if dl_method == "none":
         try:
-            from .cd_models.change_model import has_siamese_weights, predict_siamese
-            if has_siamese_weights():
-                _, dl_score = predict_siamese(img1, img2, threshold=2.0)
+            from .cd_models.change_model import is_siamese_available, predict_siamese
+            if is_siamese_available():
+                dl_mask, dl_score = predict_siamese(img1, img2, threshold=thr)
                 dl_method = "siamese_unet"
         except Exception:
             pass
 
-    classical_score, _ = _compute_classical_score_map(
-        img1, img2, registration_ok=registration_ok)
+    classical_mask = _multiscale_classical(
+        img1, img2, sensitivity=sensitivity, registration_ok=registration_ok)
+    conf_map = _build_confidence_map_from_channels(
+        img1, img2, dl_score=dl_score if dl_method != "none" else None)
 
-    if dl_method != "none" and dl_score is not None:
-        final_mask, _, fuse_debug = fuse_dl_and_classical(
-            dl_score, classical_score, img1, img2, sensitivity=sensitivity)
-        debug = {
-            "method": f"Hybrid AI ({dl_method} + gated fusion)",
-            "dl_method": dl_method,
-            "sensitivity": float(sensitivity),
-            **fuse_debug,
-        }
-        return final_mask, debug
+    dl_w = 0.7 if dl_method != "none" else 0.0
+    cl_w = 1.0 - dl_w
+    fused = dl_w * dl_mask.astype(np.float32) + cl_w * classical_mask.astype(np.float32)
 
-    mask, _, core_debug = _ai_fusion_core(
-        img1, img2, sensitivity=sensitivity, registration_ok=registration_ok)
-    return mask, {"method": "Hybrid AI (classical fallback)", "core": core_debug}
+    if conf_map is not None:
+        conf_boost = np.clip(conf_map * 1.5, 0, 1)
+        fused = fused * (0.6 + 0.4 * conf_boost)
+
+    fused_thr = max(80, int(128 - (sensitivity - 0.5) * 60))
+    _, final_mask = cv2.threshold(fused.astype(np.uint8), fused_thr, 255, cv2.THRESH_BINARY)
+    final_mask = _clean_mask(final_mask, sensitivity=sensitivity)
+
+    debug = {
+        "method": f"Hybrid AI ({dl_method} + multi-scale classical)",
+        "dl_method": dl_method,
+        "threshold_used": fused_thr,
+        "sensitivity": float(sensitivity),
+        "dl_changed_px": int(np.sum(dl_mask > 127)),
+        "classical_changed_px": int(np.sum(classical_mask > 127)),
+        "final_changed_px": int(np.sum(final_mask > 127)),
+    }
+    return final_mask, debug
 
 
 ALIGNMENT_WARNING_MSG = (
@@ -999,7 +1134,7 @@ def _clean_mask(mask, sensitivity=0.5, border_margin=12):
     filled = cv2.dilate(filled, k_break, iterations=1)
 
     # 7. Component-level filtering: remove tiny survivors and elongated noise
-    min_component_px = max(200, int(h * w * 0.00003))
+    min_component_px = max(80, int(h * w * 0.000035))
     num_labels, labels, stats, _ = cv2.connectedComponentsWithStats(filled, connectivity=8)
     clean = np.zeros_like(filled)
     for i in range(1, num_labels):
@@ -1370,20 +1505,23 @@ def classify_object_type(image_region, bbox, before_region=None):
 
     # ---- Water Body Change ----
     water = 0.0
-    if feat_a["blue_ratio"] > 0.36:
-        water += 0.22
-    if feat_a["texture_std"] < 28:
-        water += 0.18
-    if feat_a["edge_density"] < 35:
-        water += 0.14
-    if 90 <= feat_a["hue"] <= 135:
-        water += 0.18
-    if feat_a["lbp_variance"] < 0.05:
-        water += 0.14
-    if feat_a["glcm_contrast"] < 500:
-        water += 0.10
-    if area > 800:
-        water += 0.04
+    if diff and _structural_evidence(diff, feat_a) >= 0.25:
+        water = 0.0  # structural change — skip water scoring entirely
+    else:
+        if feat_a["blue_ratio"] > 0.38:
+            water += 0.22
+        if feat_a["texture_std"] < 26:
+            water += 0.18
+        if feat_a["edge_density"] < 28:
+            water += 0.16
+        if 95 <= feat_a["hue"] <= 130:
+            water += 0.18
+        if feat_a["lbp_variance"] < 0.045:
+            water += 0.14
+        if feat_a["glcm_contrast"] < 450:
+            water += 0.08
+        if area > 1200:
+            water += 0.04
     scores["Water Body Change"] = water
 
     # ---- Vegetation Change ----
@@ -1663,10 +1801,9 @@ def classify_object_type(image_region, bbox, before_region=None):
         soil += 0.10
     scores["Bare Land/Soil Change"] = soil
 
-    best = max(scores, key=scores.get)
-    conf = scores[best]
+    best, conf = _resolve_classification(scores, diff, feat_a)
 
-    if conf < 0.22:
+    if conf < 0.28:
         return "Unclassified", conf
     return best, min(conf, 1.0)
 
@@ -2356,7 +2493,7 @@ def analyze_change_regions(change_mask, image, min_area=400, use_ensemble=True,
     # - keeps sensitivity on smaller images
     # - suppresses speckle noise on larger images
     if min_area is None:
-        min_area = int(max(200, min(1000, img_area * 0.00008)))
+        min_area = int(max(250, min(1000, img_area * 0.00009)))
 
     for i in range(1, num_labels):
         raw_area = stats[i, cv2.CC_STAT_AREA]
@@ -2366,7 +2503,7 @@ def analyze_change_regions(change_mask, image, min_area=400, use_ensemble=True,
         x, y, w, h, fill_ratio = _tight_bbox(labels, i, stats[i])
 
         # Reject very sparse regions (bbox is mostly empty)
-        if fill_ratio < 0.12:
+        if fill_ratio < 0.15:
             continue
 
         # Keep large real changes; only suppress near-full-frame artifacts.
@@ -2385,14 +2522,16 @@ def analyze_change_regions(change_mask, image, min_area=400, use_ensemble=True,
                 image, (x, y, w, h), before_region=before_img)
 
         if object_type is None:
-            # Do not silently drop large coherent regions; keep them as generic
-            # ground-change candidates so key changes are still surfaced.
-            if raw_area >= max(min_area * 2, 800) and fill_ratio >= 0.18:
+            # Keep large coherent regions as generic ground change only when well-filled
+            if raw_area >= max(min_area * 2, 900) and fill_ratio >= 0.20:
                 object_type = "Unclassified Ground Change"
                 confidence = max(0.2, min(0.5, fill_ratio))
             else:
                 continue
 
+        if confidence < 0.24 and raw_area < min_area * 3:
+            continue
+
         region_id += 1
         region = {
             "id": region_id,
@@ -2456,10 +2595,12 @@ def analyze_change_regions(change_mask, image, min_area=400, use_ensemble=True,
 
 def run_detection(before_pil, after_pil, method="AI-Based Deep Learning",
                   enable_registration=True, enable_normalization=True,
-                  detection_sensitivity=0.5, min_region_area=None):
+                  detection_sensitivity=0.5, min_region_area=None,
+                  max_size=None):
     """Run full detection pipeline; returns change_mask, result_image, stats, regions."""
-    before_array = preprocess_image(before_pil)
-    after_array = preprocess_image(after_pil)
+    ms = max_size or get_detection_max_size()
+    before_array = preprocess_image(before_pil, max_size=ms)
+    after_array = preprocess_image(after_pil, max_size=ms)
 
     registration_ok = False
     reg_meta = {}

app/main.py

@@ -81,14 +81,18 @@ setup_dda(app)
 
 @app.get("/health")
 def health():
-    """Lightweight health check so Hugging Face can mark the Space as running quickly."""
+    """Health check + AdaptFormer model status (HF Spaces + diagnostics)."""
     from datetime import datetime
+    from .model_inference import get_model_status
+
+    model = get_model_status()
     return {
-        "status": "ok",
-        "version": "2.3.0-dda" if IS_DDA_MODE else "2.2.0",
+        "status": "ok" if model.get("available") else "degraded",
+        "version": "2.3.0-dda" if IS_DDA_MODE else "2.2.1",
         "appMode": "dda" if IS_DDA_MODE else "legacy",
         "spaceId": os.environ.get("SPACE_ID", ""),
         "server_time_ist": _isoformat_ist(datetime.now(timezone.utc)),
+        "adaptFormer": model,
     }
 
 

app/model_inference.py

@@ -22,6 +22,7 @@ _MODEL_ID = "deepang/adaptformer-LEVIR-CD"
 _TILE_SIZE = 256  # LEVIR-CD native patch size
 _AVAILABLE = None
 _LOAD_FAILED = False
+_LOAD_ERROR: str | None = None
 
 
 def _try_import():
@@ -34,7 +35,7 @@ def _try_import():
 
 
 def _load_model():
-    global _MODEL, _PROCESSOR, _DEVICE, _AVAILABLE, _LOAD_FAILED
+    global _MODEL, _PROCESSOR, _DEVICE, _AVAILABLE, _LOAD_FAILED, _LOAD_ERROR
     if _MODEL is not None:
         return _MODEL, _PROCESSOR
     if _LOAD_FAILED:
@@ -56,10 +57,12 @@ def _load_model():
         _MODEL.to(_DEVICE)
         _MODEL.eval()
         _AVAILABLE = True
+        _LOAD_ERROR = None
         logger.info("AdaptFormer loaded on %s", _DEVICE)
     except Exception as exc:
         _LOAD_FAILED = True
         _AVAILABLE = False
+        _LOAD_ERROR = str(exc)
         logger.error("AdaptFormer load failed: %s", exc)
         raise
     return _MODEL, _PROCESSOR
@@ -81,15 +84,38 @@ def is_model_available():
 
 def preload_model():
     """Warm-load AdaptFormer at app startup (best-effort)."""
+    global _LOAD_ERROR
     try:
         _load_model()
         logger.info("AdaptFormer preload complete")
         return True
     except Exception as exc:
+        _LOAD_ERROR = str(exc)
         logger.warning("AdaptFormer preload skipped: %s", exc)
         return False
 
 
+def get_model_status() -> dict:
+    """Status for /health — shows whether AI detection or classical fallback is active."""
+    if _AVAILABLE is True:
+        mode = "adaptformer_smart_union"
+        available = True
+    elif _LOAD_FAILED:
+        mode = "classical_fallback"
+        available = False
+    else:
+        available = is_model_available()
+        mode = "adaptformer_smart_union" if available else "classical_fallback"
+
+    return {
+        "modelId": _MODEL_ID,
+        "available": available,
+        "detectionMode": mode,
+        "device": str(_DEVICE) if _DEVICE is not None else None,
+        "error": _LOAD_ERROR,
+    }
+
+
 def predict_change_mask(img1, img2, threshold=0.5):
     """
     Run AdaptFormer inference on two RGB numpy arrays (H, W, 3).

requirements.txt

@@ -11,9 +11,10 @@ python-jose[cryptography]>=3.3.0
 passlib[bcrypt]>=1.7.4
 bcrypt==4.0.1
 pillow>=10.0.0
-numpy>=1.24.0
+numpy>=1.26,<2
 opencv-python-headless>=4.8.0
 scikit-learn>=1.3.0
 requests>=2.28.0
-rasterio>=1.3.0
+protobuf>=5.28.0,<6
+rasterio>=1.3.0,<1.5
 pyproj>=3.6.0

static/css/dda.css

@@ -317,3 +317,33 @@
   background: linear-gradient(90deg, var(--grad-start), var(--grad-end, #10b981));
   transition: width 0.15s ease;
 }
+
+.dda-hierarchy-wrap {
+  margin-top: 1rem;
+  padding-top: 0.75rem;
+  border-top: 1px solid var(--border);
+}
+.dda-hierarchy-title {
+  font-size: 0.75rem;
+  text-transform: uppercase;
+  letter-spacing: 0.04em;
+  margin: 0 0 0.5rem;
+  color: var(--text-muted, #888);
+}
+.dda-hierarchy-zone { margin-bottom: 0.35rem; }
+.dda-hierarchy-zone summary {
+  cursor: pointer;
+  font-size: 0.85rem;
+  font-weight: 600;
+  padding: 0.2rem 0;
+}
+.dda-hierarchy-list {
+  list-style: none;
+  margin: 0.25rem 0 0.5rem 0.75rem;
+  padding: 0;
+  font-size: 0.8rem;
+}
+.dda-hierarchy-village { padding: 0.15rem 0; }
+
+.regions-table tr.region-selected { background: rgba(16, 185, 129, 0.12); }
+.regions-table tr { cursor: pointer; }

static/js/dda/app.js

@@ -121,11 +121,41 @@ async function initDda() {
     localYears = yearsData.years || [];
     if (typeof renderYearTree === 'function') renderYearTree(localYears);
     await loadLibraryImages();
+    await loadHierarchyTree();
   } catch (err) {
     showDdaError(err.message || 'Failed to load library');
   }
 }
 
+async function loadHierarchyTree() {
+  const el = document.getElementById('lib-hierarchy');
+  if (!el) return;
+  try {
+    const data = await ddaApi('GET', '/api/dda/hierarchy');
+    const zones = data.zones || [];
+    if (!zones.length) {
+      el.innerHTML = '<p class="dim">No zones seeded.</p>';
+      return;
+    }
+    el.innerHTML = zones.map((z) => {
+      const villages = z.villages || [];
+      const zoneCount = villages.reduce((s, v) => s + (v.imageCount || 0), 0);
+      const villageItems = villages.map((v) =>
+        `<li class="dda-hierarchy-village">${v.name}${v.imageCount ? ` <span class="dim">(${v.imageCount})</span>` : ''}</li>`
+      ).join('');
+      return `
+        <details class="dda-hierarchy-zone" open>
+          <summary>${z.name}${zoneCount ? ` <span class="dim">(${zoneCount})</span>` : ''}</summary>
+          <ul class="dda-hierarchy-list">${villageItems || '<li class="dim">No villages</li>'}</ul>
+        </details>`;
+    }).join('');
+  } catch (_) {
+    el.innerHTML = '<p class="dim">Zone tree unavailable.</p>';
+  }
+}
+
+window.loadHierarchyTree = loadHierarchyTree;
+
 async function loadLibraryImages() {
   const grid = document.getElementById('lib-grid');
   const title = document.getElementById('lib-grid-title');

static/js/dda/compare.js

@@ -291,6 +291,22 @@ function showDetectResult(data) {
   else if (typeof showDdaError === 'function') showDdaError('Result viewer failed to load.');
 }
 
+async function runDetectionWithFallback(form, loadingEl) {
+  const hosted = window.ddaState?.localCfg?.isHosted;
+  if (hosted) {
+    loadingEl.textContent = 'Queuing detection job…';
+    try {
+      const queued = await ddaApi('POST', '/api/dda/jobs', { body: form });
+      return await pollJobUntilDone(queued.jobId, loadingEl);
+    } catch (err) {
+      const msg = String(err.message || '');
+      if (!msg.includes('Not Found') && !msg.includes('404')) throw err;
+      loadingEl.textContent = 'Running detection (sync fallback)…';
+    }
+  }
+  return ddaApi('POST', '/api/dda/detect/from-library', { body: form });
+}
+
 async function pollJobUntilDone(jobId, loadingEl) {
   const maxAttempts = 600;
   for (let i = 0; i < maxAttempts; i++) {
@@ -330,7 +346,7 @@ async function runLibraryDetection() {
   if (!Number.isNaN(minArea) && minArea >= 50) form.append('min_region_area', String(Math.round(minArea)));
 
   try {
-    const data = await ddaApi('POST', '/api/dda/detect/from-library', { body: form });
+    const data = await runDetectionWithFallback(form, loading);
     showDetectResult(data);
     if (typeof showDdaSuccess === 'function') showDdaSuccess('Detection complete.');
     if (typeof loadReportsList === 'function') loadReportsList();

static/js/dda/result.js

@@ -99,7 +99,7 @@ function showDdaResult(data) {
       <td>${subType}</td>
       <td><span class="severity-badge ${severity}">${severity}</span></td>
       <td>${(r.confidence * 100).toFixed(1)}%</td>
-      <td>${r.area.toLocaleString()}</td>
+      <td>${r.areaSqM != null ? r.areaSqM.toLocaleString() + ' m²' : r.area.toLocaleString()}</td>
       <td>(${r.center.x}, ${r.center.y})</td>
       <td>${stories}</td>
       <td>${height}</td>
@@ -156,38 +156,63 @@ function renderDdaRegionPage() {
 function setupDdaRegionHover(tbody, regions) {
   const overlay = document.getElementById('region-highlight-overlay');
   if (!overlay) return;
-  overlay.innerHTML = '';
+
+  function showRegionHighlight(r, zoomTo) {
+    if (!r || !r.bbox) return;
+    overlay.innerHTML = '';
+    const box = document.createElement('div');
+    box.className = 'highlight-box';
+    const imgEl = document.getElementById('compare-after-img');
+    const slider = document.getElementById('compare-slider');
+    const wrapper = document.getElementById('zoom-wrapper');
+    if (!imgEl || !slider || !imgEl.naturalWidth) return;
+    const rw = slider.offsetWidth;
+    const rh = slider.offsetHeight;
+    const imgW = imgEl.naturalWidth || 1;
+    const imgH = imgEl.naturalHeight || 1;
+    const scale = Math.min(rw / imgW, rh / imgH);
+    const drawW = imgW * scale;
+    const drawH = imgH * scale;
+    const offsetX = (rw - drawW) / 2;
+    const offsetY = (rh - drawH) / 2;
+    box.style.left = (offsetX + r.bbox.x * scale) + 'px';
+    box.style.top = (offsetY + r.bbox.y * scale) + 'px';
+    box.style.width = (r.bbox.w * scale) + 'px';
+    box.style.height = (r.bbox.h * scale) + 'px';
+    overlay.appendChild(box);
+
+    if (zoomTo && wrapper && r.bbox.w > 0 && r.bbox.h > 0) {
+      const cx = r.bbox.x + r.bbox.w / 2;
+      const cy = r.bbox.y + r.bbox.h / 2;
+      const targetZoom = Math.min(DDA_ZOOM_MAX, Math.max(1.5, Math.min(drawW / (r.bbox.w * scale * 2.5), drawH / (r.bbox.h * scale * 2.5))));
+      ddaZoom = targetZoom;
+      applyDdaZoom();
+      wrapper.scrollLeft = Math.max(0, (offsetX + cx * scale) * ddaZoom - wrapper.clientWidth / 2);
+      wrapper.scrollTop = Math.max(0, (offsetY + cy * scale) * ddaZoom - wrapper.clientHeight / 2);
+    }
+  }
+
   tbody.querySelectorAll('tr[data-region-id]').forEach((tr) => {
+    tr.style.cursor = 'pointer';
+    tr.title = 'Click to locate on map';
     tr.addEventListener('mouseenter', () => {
       const id = parseInt(tr.dataset.regionId, 10);
       const r = regions.find((x) => x.id === id);
-      if (!r || !r.bbox) return;
       tbody.querySelectorAll('tr').forEach((row) => row.classList.remove('region-hover'));
       tr.classList.add('region-hover');
-      const box = document.createElement('div');
-      box.className = 'highlight-box';
-      const imgEl = document.getElementById('compare-after-img');
-      const slider = document.getElementById('compare-slider');
-      if (!imgEl || !slider || !imgEl.naturalWidth) return;
-      const rw = slider.offsetWidth;
-      const rh = slider.offsetHeight;
-      const imgW = imgEl.naturalWidth || 1;
-      const imgH = imgEl.naturalHeight || 1;
-      const scale = Math.min(rw / imgW, rh / imgH);
-      const drawW = imgW * scale;
-      const drawH = imgH * scale;
-      const offsetX = (rw - drawW) / 2;
-      const offsetY = (rh - drawH) / 2;
-      box.style.left = (offsetX + r.bbox.x * scale) + 'px';
-      box.style.top = (offsetY + r.bbox.y * scale) + 'px';
-      box.style.width = (r.bbox.w * scale) + 'px';
-      box.style.height = (r.bbox.h * scale) + 'px';
-      overlay.appendChild(box);
+      showRegionHighlight(r, false);
     });
     tr.addEventListener('mouseleave', () => {
       tr.classList.remove('region-hover');
       overlay.innerHTML = '';
     });
+    tr.addEventListener('click', () => {
+      const id = parseInt(tr.dataset.regionId, 10);
+      const r = regions.find((x) => x.id === id);
+      tbody.querySelectorAll('tr').forEach((row) => row.classList.remove('region-selected'));
+      tr.classList.add('region-selected');
+      showRegionHighlight(r, true);
+    });
   });
 }
 

templates/index_dda.html

@@ -5,7 +5,7 @@
   <meta name="viewport" content="width=device-width, initial-scale=1.0" />
   <title>DDA Change Detection</title>
   <link rel="stylesheet" href="/static/css/style.css?v=30" />
-  <link rel="stylesheet" href="/static/css/dda.css?v=7" />
+  <link rel="stylesheet" href="/static/css/dda.css?v=8" />
 </head>
 <body>
   <div class="app dda-app">
@@ -36,6 +36,10 @@
           <div id="lib-folder-path" class="dda-folder-path dim"></div>
           <input type="search" id="lib-tree-search" class="dda-search" placeholder="Filter years…" />
           <div id="lib-tree" class="dda-tree"><p class="dim">Loading…</p></div>
+          <div class="dda-hierarchy-wrap">
+            <h4 class="dda-hierarchy-title">DDA zones</h4>
+            <div id="lib-hierarchy" class="dda-hierarchy"><p class="dim">Loading…</p></div>
+          </div>
         </aside>
         <main class="dda-main">
           <div class="card dda-instructions">
@@ -228,10 +232,10 @@
     </div>
   </div>
 
-  <script src="/static/js/dda/app.js?v=9"></script>
-  <script src="/static/js/dda/library.js?v=5"></script>
-  <script src="/static/js/dda/result.js?v=3"></script>
-  <script src="/static/js/dda/compare.js?v=6"></script>
-  <script src="/static/js/dda/reports.js?v=1"></script>
+  <script src="/static/js/dda/app.js?v=10"></script>
+  <script src="/static/js/dda/library.js?v=6"></script>
+  <script src="/static/js/dda/result.js?v=4"></script>
+  <script src="/static/js/dda/compare.js?v=7"></script>
+  <script src="/static/js/dda/reports.js?v=2"></script>
 </body>
 </html>