Improve detection accuracy with full-res tiling, config flags, and evaluation.

Centralize detection tuning in detection_config, add windowed GeoTIFF inference
for large rasters, optional hysteresis fusion and multi-scale DL, synthetic
benchmark metrics, and local stability fixes for rescan and job queuing.

.env.example

@@ -17,6 +17,33 @@
 # Max pixel dimension for detection (lower = less RAM, default 4096 local)
 # DETECTION_MAX_SIDE=4096
 
+# --- Accuracy controls (all optional; defaults preserve current behavior) ---
+# Inference mode: downscaled (default) or fullres_tiled (native detail for large GeoTIFFs)
+# DETECTION_INFERENCE_MODE=downscaled
+# Full-res cap (px) in fullres_tiled mode; 0 = native resolution
+# DETECTION_FULLRES_MAX_SIDE=8192
+# Native side (px) above which GeoTIFFs stream from disk windows (avoids OOM)
+# DETECTION_WINDOWED_THRESHOLD=8192
+# Soft RAM budget (MB) per in-memory array before switching to windowed streaming
+# DETECTION_TILE_MEMORY_MB=1536
+# Tile size / overlap for full-res scoring
+# DETECTION_TILE_SIZE=512
+# DETECTION_TILE_OVERLAP=0.25
+# Multi-scale DL fusion: off or a comma list, e.g. 0.5,1.0,1.5
+# DETECTION_MULTISCALE=off
+# Fusion strategy: smart_union (default) or hysteresis
+# DETECTION_FUSION=smart_union
+# Preprocessing toggles
+# DETECTION_CLAHE=true
+# DETECTION_HIST_MATCH=false
+# DETECTION_SKIP_PREBLUR=         # auto: on in fullres_tiled mode
+# Border pixels zeroed in mask cleanup (auto: 4 fullres / 12 downscaled)
+# DETECTION_BORDER_MARGIN=
+# Tiles per GPU forward pass (1 = no batching)
+# DETECTION_TILE_BATCH=1
+# Save a downsampled probability-map PNG per run for debugging
+# DETECTION_SAVE_PROB_MAP=false
+
 # Public URL for report links in emails (default http://localhost:8000 locally)
 # PUBLIC_BASE_URL=http://localhost:8000
 

DEPLOYMENT.md

@@ -145,6 +145,26 @@ Set these in each Space’s **Settings → Repository secrets / Variables** if n
 | `DDA_ADMIN_EMAIL` / `DDA_ADMIN_PASSWORD` | Seed admin user on dev (role: admin) |
 | `DDA_TRAINING_EXPORT_KEY` | Header `X-DDA-Training-Key` for false-positive export |
 
+### Detection accuracy controls (optional, dev-first)
+
+All default to the previous behavior, so leaving them unset changes nothing.
+
+| Variable | Purpose |
+|----------|---------|
+| `DETECTION_MAX_SIDE` | Downscaled-path pixel cap (default 4096 local / 2048 hosted) |
+| `DETECTION_INFERENCE_MODE` | `downscaled` (default) or `fullres_tiled` (native detail) |
+| `DETECTION_FULLRES_MAX_SIDE` | Full-res cap in fullres mode; 0 = native (default 8192) |
+| `DETECTION_WINDOWED_THRESHOLD` | Native side above which GeoTIFFs stream from disk windows (default 8192) |
+| `DETECTION_TILE_MEMORY_MB` | RAM budget per array before switching to windowed streaming (default 1536) |
+| `DETECTION_TILE_SIZE` / `DETECTION_TILE_OVERLAP` | Full-res tile geometry (default 512 / 0.25) |
+| `DETECTION_MULTISCALE` | `off` or scale list e.g. `0.5,1.0,1.5` (max-fused for recall) |
+| `DETECTION_FUSION` | `smart_union` (default) or `hysteresis` |
+| `DETECTION_CLAHE` / `DETECTION_HIST_MATCH` | Preprocessing toggles (CLAHE on, hist-match off) |
+| `DETECTION_SKIP_PREBLUR` | Skip denoise (auto-on in fullres mode) |
+| `DETECTION_BORDER_MARGIN` | Mask border zeroing (auto: 4 fullres / 12 downscaled) |
+| `DETECTION_TILE_BATCH` | Tiles per GPU forward pass (default 1) |
+| `DETECTION_SAVE_PROB_MAP` | Save a per-run probability PNG for debugging (default off) |
+
 Dev Space can omit `SECRET_KEY` (login is disabled on both Spaces).
 
 ---

app/cd_models/change_model.py

@@ -189,54 +189,23 @@ def predict_siamese(img1, img2, threshold=0.5):
     if img1.shape != img2.shape:
         img2 = cv2.resize(img2, (img1.shape[1], img1.shape[0]))
 
-    h, w = img1.shape[:2]
-    tile = _TILE
-    overlap = tile // 4
-    stride = tile - overlap
-
-    pad_h = (tile - h % tile) % tile
-    pad_w = (tile - w % tile) % tile
-    if pad_h or pad_w:
-        img1 = np.pad(img1, ((0, pad_h), (0, pad_w), (0, 0)), mode="reflect")
-        img2 = np.pad(img2, ((0, pad_h), (0, pad_w), (0, 0)), mode="reflect")
-
-    ph, pw = img1.shape[:2]
-    score_sum = np.zeros((ph, pw), dtype=np.float32)
-    count = np.zeros((ph, pw), dtype=np.float32)
-
-    ramp = np.linspace(0, 1, overlap)
-    flat = np.ones(tile - 2 * overlap)
-    profile = np.concatenate([ramp, flat, ramp[::-1]])
-    weight_2d = np.outer(profile, profile).astype(np.float32)
+    from .model_utils import tiled_score_map
 
     mean = np.array([0.485, 0.456, 0.406], dtype=np.float32)
     std = np.array([0.229, 0.224, 0.225], dtype=np.float32)
 
-    with torch.no_grad():
-        for y0 in range(0, ph - tile + 1, stride):
-            for x0 in range(0, pw - tile + 1, stride):
-                t1 = img1[y0:y0+tile, x0:x0+tile].astype(np.float32) / 255.0
-                t2 = img2[y0:y0+tile, x0:x0+tile].astype(np.float32) / 255.0
-
-                t1 = (t1 - mean) / std
-                t2 = (t2 - mean) / std
-
-                ta = torch.from_numpy(t1.transpose(2, 0, 1)).unsqueeze(0).to(_DEVICE)
-                tb = torch.from_numpy(t2.transpose(2, 0, 1)).unsqueeze(0).to(_DEVICE)
-
-                logits = model(ta, tb)
-                probs = torch.softmax(logits, dim=1)
-                prob_map = probs[0, 1].cpu().numpy()
+    def _score_tile(t1, t2):
+        n1 = (t1.astype(np.float32) / 255.0 - mean) / std
+        n2 = (t2.astype(np.float32) / 255.0 - mean) / std
+        ta = torch.from_numpy(n1.transpose(2, 0, 1)).unsqueeze(0).to(_DEVICE)
+        tb = torch.from_numpy(n2.transpose(2, 0, 1)).unsqueeze(0).to(_DEVICE)
+        logits = model(ta, tb)
+        probs = torch.softmax(logits, dim=1)
+        return probs[0, 1].cpu().numpy()
 
-                if prob_map.shape != (tile, tile):
-                    prob_map = cv2.resize(prob_map, (tile, tile))
-
-                score_sum[y0:y0+tile, x0:x0+tile] += prob_map * weight_2d
-                count[y0:y0+tile, x0:x0+tile] += weight_2d
-
-    count = np.maximum(count, 1e-6)
-    avg = score_sum / count
-    avg = avg[:h, :w]
+    with torch.no_grad():
+        avg = tiled_score_map(_score_tile, img1, img2,
+                              tile_size=_TILE, overlap=_TILE // 4)
 
     mask = (avg >= threshold).astype(np.uint8) * 255
     return mask, avg

app/cd_models/model_utils.py

@@ -5,6 +5,95 @@ import cv2
 import numpy as np
 
 
+def make_blend_weights(tile_size: int, overlap: int) -> np.ndarray:
+    """Raised-cosine (trapezoid) 2D weight for seamless tile stitching.
+
+    Ramps from 0 to 1 across the overlap band on each edge and stays flat in
+    the interior, so overlapping tile predictions blend without visible seams.
+    """
+    overlap = max(0, min(overlap, tile_size // 2))
+    if overlap == 0:
+        return np.ones((tile_size, tile_size), dtype=np.float32)
+    ramp = np.linspace(0.0, 1.0, overlap, dtype=np.float32)
+    flat = np.ones(tile_size - 2 * overlap, dtype=np.float32)
+    profile = np.concatenate([ramp, flat, ramp[::-1]])
+    return np.outer(profile, profile).astype(np.float32)
+
+
+def tiled_score_map(score_tile_fn, img1, img2, tile_size: int = 256,
+                    overlap: int | None = None,
+                    score_batch_fn=None, batch: int = 1):
+    """Sliding-window tiled scoring with reflect padding + cosine blending.
+
+    ``score_tile_fn(tile1, tile2)`` must return a float32 array in [0, 1] the
+    same height/width as the input tile. Returns a float32 change-probability
+    map cropped back to the original (h, w). This is the single shared
+    implementation used by every deep model so blending stays consistent.
+
+    When ``batch > 1`` and ``score_batch_fn`` is provided, tiles are scored in
+    groups (``score_batch_fn(list[(t1, t2)]) -> list[prob]``) so GPUs can run
+    several tiles per forward pass.
+    """
+    h, w = img1.shape[:2]
+    if overlap is None:
+        overlap = tile_size // 4
+    overlap = max(0, min(overlap, tile_size // 2))
+    stride = max(1, tile_size - overlap)
+
+    pad_h = (tile_size - h % tile_size) % tile_size
+    pad_w = (tile_size - w % tile_size) % tile_size
+    # Guarantee at least one full tile even for small inputs
+    pad_h = max(pad_h, max(0, tile_size - h))
+    pad_w = max(pad_w, max(0, tile_size - w))
+    if pad_h or pad_w:
+        img1 = np.pad(img1, ((0, pad_h), (0, pad_w), (0, 0)), mode="reflect")
+        img2 = np.pad(img2, ((0, pad_h), (0, pad_w), (0, 0)), mode="reflect")
+
+    ph, pw = img1.shape[:2]
+    score_sum = np.zeros((ph, pw), dtype=np.float32)
+    count = np.zeros((ph, pw), dtype=np.float32)
+    weight_2d = make_blend_weights(tile_size, overlap)
+
+    ys = list(range(0, ph - tile_size + 1, stride))
+    xs = list(range(0, pw - tile_size + 1, stride))
+    # Ensure the far edges are always covered
+    if ys and ys[-1] != ph - tile_size:
+        ys.append(ph - tile_size)
+    if xs and xs[-1] != pw - tile_size:
+        xs.append(pw - tile_size)
+
+    coords = [(y0, x0) for y0 in ys for x0 in xs]
+
+    def _accumulate(y0, x0, prob):
+        if prob.shape != (tile_size, tile_size):
+            prob = cv2.resize(prob.astype(np.float32), (tile_size, tile_size),
+                              interpolation=cv2.INTER_LINEAR)
+        score_sum[y0:y0 + tile_size, x0:x0 + tile_size] += prob * weight_2d
+        count[y0:y0 + tile_size, x0:x0 + tile_size] += weight_2d
+
+    use_batch = score_batch_fn is not None and batch > 1
+    if use_batch:
+        for i in range(0, len(coords), batch):
+            chunk = coords[i:i + batch]
+            pairs = [
+                (np.ascontiguousarray(img1[y:y + tile_size, x:x + tile_size]),
+                 np.ascontiguousarray(img2[y:y + tile_size, x:x + tile_size]))
+                for (y, x) in chunk
+            ]
+            probs = score_batch_fn(pairs)
+            for (y0, x0), prob in zip(chunk, probs):
+                _accumulate(y0, x0, prob)
+    else:
+        for (y0, x0) in coords:
+            t1 = np.ascontiguousarray(img1[y0:y0 + tile_size, x0:x0 + tile_size])
+            t2 = np.ascontiguousarray(img2[y0:y0 + tile_size, x0:x0 + tile_size])
+            _accumulate(y0, x0, score_tile_fn(t1, t2))
+
+    count = np.maximum(count, 1e-6)
+    avg = score_sum / count
+    return avg[:h, :w]
+
+
 def split_into_tiles(img, tile_size=512, overlap=64):
     """
     Split an image into overlapping tiles.

app/dda/bootstrap.py

@@ -18,6 +18,60 @@ from .dda_auth import seed_dda_admin
 logger = logging.getLogger(__name__)
 
 
+def _migrate_detection_jobs_nullable() -> None:
+    """SQLite legacy schema required image asset FKs; tree library jobs use paths only."""
+    try:
+        with engine.connect() as conn:
+            rows = conn.execute(sa_text("PRAGMA table_info(dda_detection_jobs)")).fetchall()
+            if not rows:
+                return
+            by_name = {r[1]: r for r in rows}
+            base_col = by_name.get("base_image_id")
+            if not base_col or base_col[3] == 0:
+                return
+            logger.info("Migrating dda_detection_jobs to allow NULL image IDs for path-based jobs")
+            conn.execute(sa_text("PRAGMA foreign_keys=OFF"))
+            conn.execute(sa_text("""
+                CREATE TABLE dda_detection_jobs_new (
+                    id INTEGER NOT NULL PRIMARY KEY,
+                    status VARCHAR(32),
+                    base_image_id INTEGER,
+                    comparison_image_id INTEGER,
+                    method VARCHAR(64),
+                    params_json TEXT,
+                    run_id INTEGER,
+                    error_message TEXT,
+                    notify_email VARCHAR(255),
+                    created_by INTEGER,
+                    started_at DATETIME,
+                    completed_at DATETIME,
+                    created_at DATETIME,
+                    FOREIGN KEY(base_image_id) REFERENCES dda_image_assets (id),
+                    FOREIGN KEY(comparison_image_id) REFERENCES dda_image_assets (id),
+                    FOREIGN KEY(run_id) REFERENCES detection_runs (id),
+                    FOREIGN KEY(created_by) REFERENCES users (id)
+                )
+            """))
+            conn.execute(sa_text("""
+                INSERT INTO dda_detection_jobs_new (
+                    id, status, base_image_id, comparison_image_id, method, params_json,
+                    run_id, error_message, notify_email, created_by,
+                    started_at, completed_at, created_at
+                )
+                SELECT
+                    id, status, base_image_id, comparison_image_id, method, params_json,
+                    run_id, error_message, notify_email, created_by,
+                    started_at, completed_at, created_at
+                FROM dda_detection_jobs
+            """))
+            conn.execute(sa_text("DROP TABLE dda_detection_jobs"))
+            conn.execute(sa_text("ALTER TABLE dda_detection_jobs_new RENAME TO dda_detection_jobs"))
+            conn.execute(sa_text("PRAGMA foreign_keys=ON"))
+            conn.commit()
+    except Exception as exc:
+        logger.warning("Detection jobs nullable migration skipped: %s", exc)
+
+
 def init_dda_database():
     """Run DDA-specific startup tasks (dirs, seed, migrations)."""
     if not IS_DDA_MODE:
@@ -43,6 +97,7 @@ def init_dda_database():
                 conn.commit()
             except Exception:
                 conn.rollback()
+            _migrate_detection_jobs_nullable()
     except Exception as exc:
         logger.warning("DDA schema migration skipped: %s", exc)
 
@@ -63,9 +118,12 @@ def init_dda_database():
         from .tree.migration import run_tree_migration
         mig = run_tree_migration(db)
         logger.info("Tree migration: %s", mig)
-        from .tree.sync_service import sync_from_filesystem
-        sync_stats = sync_from_filesystem(db)
-        logger.info("Filesystem sync at startup: %s", sync_stats)
+        try:
+            from .tree.sync_service import sync_from_filesystem
+            sync_stats = sync_from_filesystem(db)
+            logger.info("Filesystem sync at startup: %s", sync_stats)
+        except Exception as exc:
+            logger.warning("Filesystem sync at startup failed: %s", exc)
         from .job_runner import reconcile_stale_jobs
         reconcile_stale_jobs(db)
     finally:

app/dda/config.py

@@ -134,9 +134,5 @@ def geotiff_io_available() -> bool:
 
 def get_detection_max_side() -> int:
     """Max pixel dimension for GeoTIFF load + detection pipeline (higher = sharper, more RAM)."""
-    default = "2048" if is_hf_hosted() else "4096"
-    try:
-        value = int(os.environ.get("DETECTION_MAX_SIDE", default))
-    except ValueError:
-        value = int(default)
-    return max(1024, min(8192, value))
+    from ..detection_config import get_detection_max_side as _central
+    return _central()

app/dda/detect_service.py

@@ -79,6 +79,7 @@ def run_detection_and_save(
     notify_email: Optional[str] = None,
     max_size: Optional[int] = None,
     geo_bounds_path: Optional[Path] = None,
+    comparison_file: Optional[Path] = None,
     base_path: str = "",
     user_id: Optional[int] = None,
     job_id: Optional[int] = None,
@@ -107,6 +108,12 @@ def run_detection_and_save(
         _report(job_pct, stage)
 
     _report(15, "Running detection")
+
+    def _geotiff_path(p: Optional[Path]) -> Optional[str]:
+        if p is not None and str(p).lower().endswith((".tif", ".tiff")):
+            return str(p)
+        return None
+
     change_mask, result_image, stats, change_regions = run_detection(
         before_pil,
         after_pil,
@@ -117,6 +124,8 @@ def run_detection_and_save(
         min_region_area=min_region_area,
         max_size=max_size,
         on_progress=_on_engine_progress,
+        before_path=_geotiff_path(geo_bounds_path),
+        after_path=_geotiff_path(comparison_file),
     )
 
     _report(80, "Saving results")
@@ -133,6 +142,21 @@ def run_detection_and_save(
     Image.fromarray(result_image).save(overlay_path)
     relative_overlay = f"overlays/{overlay_filename}"
 
+    relative_prob = ""
+    try:
+        from ..detection_config import get_save_prob_map
+        score_map = stats.pop("_score_map", None)
+        if get_save_prob_map() and score_map is not None:
+            import numpy as _np
+            prob_u8 = _np.clip(score_map * 255.0, 0, 255).astype("uint8")
+            prob_img = Image.fromarray(prob_u8)
+            prob_img.thumbnail((1024, 1024), Image.Resampling.LANCZOS)
+            prob_file = OVERLAYS_DIR / f"{base_name}_prob.png"
+            prob_img.save(prob_file)
+            relative_prob = f"overlays/{base_name}_prob.png"
+    except Exception as exc:
+        logger.warning("Probability map export failed: %s", exc)
+
     relative_before_full = ""
     relative_before_thumb = ""
     relative_after_thumb = ""
@@ -261,6 +285,7 @@ def run_detection_and_save(
             "alignmentWarning": stats.get("alignment_warning"),
             "registrationOk": stats.get("params", {}).get("registration_ok"),
             "geo": geo_debug,
+            "probabilityMapUrl": f"/api/overlay/{relative_prob}" if relative_prob else None,
         },
         "regions": regions_serializable,
         "overlayBase64Png": overlay_b64,

app/dda/geotiff_io.py

@@ -210,6 +210,79 @@ def _rasterio_read_rgb(path: Path, max_side: int):
         return Image.fromarray(rgb.astype("uint8"), mode="RGB")
 
 
+def read_native_size(path: Path) -> Optional[Tuple[int, int]]:
+    """Return (width, height) of a GeoTIFF without decoding pixels, or None."""
+    ext = path.suffix.lower()
+    if ext not in (".tif", ".tiff"):
+        return None
+    try:
+        import rasterio
+        with rasterio.open(path) as src:
+            return int(src.width), int(src.height)
+    except Exception:
+        return None
+
+
+def _normalize_window_rgb(data):
+    """Convert a rasterio (bands, h, w) window read to RGB uint8 (h, w, 3)."""
+    import numpy as np
+    count = data.shape[0]
+    if count == 1:
+        rgb = np.stack([data[0], data[0], data[0]])
+    else:
+        rgb = data[:3]
+    rgb = np.transpose(rgb, (1, 2, 0)).astype("float32")
+    if rgb.max() > 255 or rgb.min() < 0:
+        lo, hi = np.percentile(rgb, (2, 98))
+        rgb = np.clip((rgb - lo) / max(hi - lo, 1e-6), 0, 1) * 255
+    return rgb.astype("uint8")
+
+
+def iter_geotiff_window_pairs(path_a: Path, path_b: Path,
+                              tile_size: int = 512, overlap: float = 0.25):
+    """Stream paired native-resolution RGB windows from two same-size GeoTIFFs.
+
+    Reads corresponding pixel windows from disk via rasterio so very large
+    rasters never load fully into RAM. Yields
+    ``(tile_a, tile_b, y0, x0, full_h, full_w)`` where tiles are RGB uint8.
+    Requires both rasters to share native pixel dimensions; raises ValueError
+    otherwise so the caller can fall back to the in-memory path.
+    """
+    import rasterio
+    from rasterio.windows import Window
+
+    tile_size = max(64, int(tile_size))
+    ov = min(0.5, max(0.0, float(overlap)))
+    step = max(1, int(round(tile_size * (1.0 - ov))))
+
+    with rasterio.open(path_a) as src_a, rasterio.open(path_b) as src_b:
+        if (src_a.width, src_a.height) != (src_b.width, src_b.height):
+            raise ValueError(
+                f"GeoTIFF dimensions differ: {src_a.width}x{src_a.height} "
+                f"vs {src_b.width}x{src_b.height}"
+            )
+        full_w, full_h = int(src_a.width), int(src_a.height)
+        bands_a = list(range(1, min(3, src_a.count) + 1))
+        bands_b = list(range(1, min(3, src_b.count) + 1))
+
+        ys = list(range(0, max(1, full_h - tile_size + 1), step))
+        xs = list(range(0, max(1, full_w - tile_size + 1), step))
+        if ys[-1] != full_h - tile_size and full_h > tile_size:
+            ys.append(full_h - tile_size)
+        if xs[-1] != full_w - tile_size and full_w > tile_size:
+            xs.append(full_w - tile_size)
+
+        for y0 in ys:
+            for x0 in xs:
+                wh = min(tile_size, full_h - y0)
+                ww = min(tile_size, full_w - x0)
+                win = Window(x0, y0, ww, wh)
+                da = src_a.read(indexes=bands_a, window=win)
+                db = src_b.read(indexes=bands_b, window=win)
+                yield (_normalize_window_rgb(da), _normalize_window_rgb(db),
+                       y0, x0, full_h, full_w)
+
+
 def load_rgb_pil(path: Path, max_side: Optional[int] = None) -> Image.Image:
     """Load image as RGB PIL, downscaling large GeoTIFFs via rasterio."""
     if max_side is None:

app/dda/job_runner.py

@@ -32,9 +32,10 @@ def _utcnow():
 
 
 def _load_pair(base_path: str, comparison_path: str) -> tuple[Image.Image, Image.Image, Path]:
+    from ..detection_config import get_load_max_side
     base_file = safe_resolve(base_path)
     comp_file = safe_resolve(comparison_path)
-    max_side = get_detection_max_side()
+    max_side = get_load_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:
@@ -71,6 +72,7 @@ def _run_job_sync(job_id: int) -> None:
 
         update_job_progress(job_id, 8, "Loading images")
         before_pil, after_pil, base_file = _load_pair(base_path, comparison_path)
+        comp_file = safe_resolve(comparison_path)
         update_job_progress(job_id, 12, "Images loaded")
         title = params.get("title") or f"{Path(base_path).name} vs {Path(comparison_path).name}"
         result = run_detection_and_save(
@@ -88,6 +90,7 @@ def _run_job_sync(job_id: int) -> None:
             notify_email=job.notify_email or params.get("notify_email"),
             max_size=get_detection_max_side(),
             geo_bounds_path=base_file,
+            comparison_file=comp_file,
             base_path=base_path,
             user_id=job.created_by,
             job_id=job_id,

app/dda/local_routes.py

@@ -111,7 +111,11 @@ def local_rescan(db: Session = Depends(get_db)):
     _require_dda()
     from .tree.sync_service import sync_from_filesystem
 
-    sync_stats = sync_from_filesystem(db)
+    try:
+        sync_stats = sync_from_filesystem(db)
+    except Exception as exc:
+        logger.exception("Filesystem rescan failed")
+        raise HTTPException(status_code=500, detail=f"Rescan failed: {exc}") from exc
     tree = build_tree(db)
     images = list_all_images(db)
     return {
@@ -158,8 +162,10 @@ async def detect_from_library(
         raise HTTPException(status_code=400, detail=f"Invalid library path: {exc}") from exc
 
     try:
-        before_pil = load_rgb_pil(base_file, max_side=get_detection_max_side())
-        after_pil = load_rgb_pil(comp_file, max_side=get_detection_max_side())
+        from ..detection_config import get_load_max_side
+        load_side = get_load_max_side()
+        before_pil = load_rgb_pil(base_file, max_side=load_side)
+        after_pil = load_rgb_pil(comp_file, max_side=load_side)
     except RuntimeError as exc:
         raise HTTPException(status_code=400, detail=str(exc)) from exc
     except Exception as exc:
@@ -187,6 +193,7 @@ async def detect_from_library(
             notify_email=notify_email,
             max_size=get_detection_max_side(),
             geo_bounds_path=base_file,
+            comparison_file=comp_file,
             base_path=base_norm,
             user_id=user.id,
         )

app/dda/tree/sync_service.py

@@ -15,10 +15,13 @@ from .models import ImageLibrary, TreeNode
 from .path_service import ensure_node_directory, storage_root
 from .path_slugs import RESERVED
 
+from .path_slugs import RESERVED
+
 logger = logging.getLogger(__name__)
 
 _NODE_TYPES = ("Zone", "Area", "Year", "Folder")
 _SKIP_DIRS = frozenset({".git", ".thumbs", "__pycache__", "cache", "thumbs"})
+_RESERVED_DIR_NAMES = RESERVED
 
 
 def _infer_node_type(depth: int) -> str:
@@ -157,6 +160,16 @@ def _index_image_file(db: Session, node: TreeNode, file_path: Path, rel_file: st
     return True
 
 
+def _node_path_for_images_folder(rel_path: str) -> Optional[str]:
+    """Resolve which tree node should own an on-disk Images/ folder."""
+    rel = (rel_path or "").strip("/")
+    while rel:
+        if rel.split("/")[-1].lower() not in _RESERVED_DIR_NAMES:
+            return rel
+        rel = "/".join(rel.split("/")[:-1])
+    return None
+
+
 def _sync_directory(db: Session, abs_dir: Path, rel_path: str, stats: dict) -> None:
     """Recursively sync nodes and images under rel_path."""
     if not abs_dir.is_dir():
@@ -169,10 +182,16 @@ def _sync_directory(db: Session, abs_dir: Path, rel_path: str, stats: dict) -> N
         child_rel = f"{rel_path}/{child.name}".strip("/") if rel_path else child.name
 
         if child.name.lower() == "images":
-            if rel_path:
-                node = _find_node_by_physical_path(db, rel_path)
+            node_rel = _node_path_for_images_folder(rel_path)
+            if node_rel:
+                node = _find_node_by_physical_path(db, node_rel)
                 if not node:
-                    node = ensure_node_from_disk(db, rel_path)
+                    try:
+                        node = ensure_node_from_disk(db, node_rel)
+                    except ValueError as exc:
+                        logger.warning("Skipping images under %s: %s", rel_path, exc)
+                        stats["foldersSkipped"] = stats.get("foldersSkipped", 0) + 1
+                        continue
                 for f in sorted(child.iterdir()):
                     if not f.is_file() or f.suffix.lower() not in ALLOWED_EXTENSIONS:
                         continue
@@ -183,8 +202,20 @@ def _sync_directory(db: Session, abs_dir: Path, rel_path: str, stats: dict) -> N
                         stats["imagesUpdated"] += 1
             continue
 
+        if child.name.lower() in _RESERVED_DIR_NAMES:
+            logger.warning("Skipping reserved folder on disk: %s", child_rel)
+            stats["foldersSkipped"] = stats.get("foldersSkipped", 0) + 1
+            _sync_directory(db, child, child_rel, stats)
+            continue
+
         before = _find_node_by_physical_path(db, child_rel)
-        ensure_node_from_disk(db, child_rel)
+        try:
+            ensure_node_from_disk(db, child_rel)
+        except ValueError as exc:
+            logger.warning("Skipping folder %s: %s", child_rel, exc)
+            stats["foldersSkipped"] = stats.get("foldersSkipped", 0) + 1
+            _sync_directory(db, child, child_rel, stats)
+            continue
         if not before:
             stats["nodesCreated"] += 1
         _sync_directory(db, child, child_rel, stats)
@@ -198,6 +229,7 @@ def sync_from_filesystem(db: Session) -> dict:
         "imagesIndexed": 0,
         "imagesUpdated": 0,
         "orphansFlagged": 0,
+        "foldersSkipped": 0,
     }
     if not root.exists():
         return stats

app/detection_config.py

@@ -0,0 +1,225 @@
+"""Centralized, env-driven detection configuration.
+
+Single source of truth for detection tuning knobs so the engine, model
+inference, and tiling utilities stay consistent. Every value is read from the
+environment with conservative defaults that preserve the previous behavior
+(``downscaled`` inference, ``smart_union`` fusion, no multi-scale).
+
+Env vars
+--------
+DETECTION_MAX_SIDE        Max pixel dimension for the legacy downscaled path.
+DETECTION_INFERENCE_MODE  ``downscaled`` (default) | ``fullres_tiled``.
+DETECTION_FULLRES_MAX_SIDE Cap for full-resolution tiled mode (0 = native).
+DETECTION_TILE_SIZE       Tile size for full-res scoring (256..2048).
+DETECTION_TILE_OVERLAP    Fractional tile overlap (0.0..0.5).
+DETECTION_MULTISCALE      ``off`` | comma list e.g. ``0.5,1.0,1.5``.
+DETECTION_FUSION          ``smart_union`` (default) | ``hysteresis``.
+DETECTION_SKIP_PREBLUR    ``true`` | ``false`` (auto: on for fullres_tiled).
+DETECTION_TTA             ``off`` | ``hflip`` | ``full`` | ``auto`` (model_inference).
+"""
+from __future__ import annotations
+
+import logging
+import os
+from typing import List
+
+_log = logging.getLogger(__name__)
+
+
+def _env(name: str, default: str = "") -> str:
+    return os.environ.get(name, default).strip()
+
+
+def get_detection_max_side() -> int:
+    """Max pixel dimension for image load + the downscaled detection path."""
+    hosted = bool(_env("SPACE_ID"))
+    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 get_inference_mode() -> str:
+    """Detection inference mode: ``downscaled`` or ``fullres_tiled``."""
+    mode = _env("DETECTION_INFERENCE_MODE", "downscaled").lower()
+    return mode if mode in ("downscaled", "fullres_tiled") else "downscaled"
+
+
+def get_fullres_max_side() -> int:
+    """Upper bound for full-res tiled mode. 0 means use native resolution.
+
+    Defaults to 8192 so very large GeoTIFFs stay bounded in RAM while still
+    running detection at far higher detail than the 2048/4096 downscaled cap.
+    """
+    raw = _env("DETECTION_FULLRES_MAX_SIDE", "8192")
+    try:
+        value = int(raw)
+    except ValueError:
+        value = 8192
+    if value <= 0:
+        return 0  # native resolution, no cap
+    return max(2048, min(20000, value))
+
+
+def get_load_max_side() -> int:
+    """Effective image-load / inference pixel cap for the active mode.
+
+    In ``fullres_tiled`` mode this returns the (much larger) full-res cap so
+    images keep their detail; otherwise it returns the standard downscale cap.
+    Always a concrete positive int so callers can pass it straight to loaders.
+    """
+    if get_inference_mode() == "fullres_tiled":
+        cap = get_fullres_max_side()
+        return cap if cap > 0 else 20000
+    return get_detection_max_side()
+
+
+def get_windowed_threshold() -> int:
+    """Native max-side above which GeoTIFF inference streams via rasterio windows.
+
+    Keeps peak RAM bounded for very large rasters: when a GeoTIFF's native
+    longest side exceeds this, the deep score map is built tile-by-tile from
+    disk instead of loading the whole array. 0 disables windowed streaming.
+    """
+    raw = _env("DETECTION_WINDOWED_THRESHOLD", "8192")
+    try:
+        value = int(raw)
+    except ValueError:
+        value = 8192
+    return max(0, value)
+
+
+def get_tile_size() -> int:
+    """Tile size (px) for full-resolution scoring."""
+    try:
+        value = int(os.environ.get("DETECTION_TILE_SIZE", "512"))
+    except ValueError:
+        value = 512
+    return max(256, min(2048, value))
+
+
+def get_tile_overlap() -> float:
+    """Fractional overlap between adjacent tiles (0.0..0.5)."""
+    try:
+        value = float(os.environ.get("DETECTION_TILE_OVERLAP", "0.25"))
+    except ValueError:
+        value = 0.25
+    return min(0.5, max(0.0, value))
+
+
+def get_multiscale_scales() -> List[float]:
+    """Scales for multi-scale fusion. Empty list disables it."""
+    raw = _env("DETECTION_MULTISCALE", "off").lower()
+    if raw in ("off", "", "none", "0", "false"):
+        return []
+    scales: List[float] = []
+    for part in raw.split(","):
+        part = part.strip()
+        if not part:
+            continue
+        try:
+            scale = float(part)
+        except ValueError:
+            continue
+        if 0.1 <= scale <= 4.0:
+            scales.append(scale)
+    # Always include native scale so recall never drops below single-scale
+    if scales and 1.0 not in scales:
+        scales.append(1.0)
+    return sorted(set(scales))
+
+
+def get_fusion_mode() -> str:
+    """DL + classical fusion strategy: ``smart_union`` or ``hysteresis``."""
+    mode = _env("DETECTION_FUSION", "smart_union").lower()
+    return mode if mode in ("smart_union", "hysteresis") else "smart_union"
+
+
+def get_skip_preblur() -> bool:
+    """Whether to skip the preprocessing Gaussian/bilateral blur.
+
+    Explicit env wins; otherwise auto-skip in full-res mode to preserve the
+    fine detail that motivates running detection at native resolution.
+    """
+    raw = _env("DETECTION_SKIP_PREBLUR", "").lower()
+    if raw in ("1", "true", "yes", "on"):
+        return True
+    if raw in ("0", "false", "no", "off"):
+        return False
+    return get_inference_mode() == "fullres_tiled"
+
+
+def _flag(name: str, default: bool) -> bool:
+    raw = _env(name, "").lower()
+    if raw in ("1", "true", "yes", "on"):
+        return True
+    if raw in ("0", "false", "no", "off"):
+        return False
+    return default
+
+
+def get_enable_clahe() -> bool:
+    """CLAHE contrast equalization during radiometric normalization (default on)."""
+    return _flag("DETECTION_CLAHE", True)
+
+
+def get_hist_match() -> bool:
+    """Optional histogram matching of the after image to the before (default off)."""
+    return _flag("DETECTION_HIST_MATCH", False)
+
+
+def get_tile_batch() -> int:
+    """Tiles per model forward pass (GPU throughput). 1 = no batching (default)."""
+    try:
+        value = int(os.environ.get("DETECTION_TILE_BATCH", "1"))
+    except ValueError:
+        value = 1
+    return max(1, min(64, value))
+
+
+def get_tile_memory_budget_mb() -> int:
+    """Soft RAM budget (MB) for a single in-memory detection array.
+
+    When loading both timestamps at the full-res cap would exceed this, large
+    GeoTIFFs switch to disk-windowed streaming so peak memory stays bounded
+    (lets 15 GB rasters run without OOM). 0 disables the budget check.
+    """
+    raw = _env("DETECTION_TILE_MEMORY_MB", "1536")
+    try:
+        value = int(raw)
+    except ValueError:
+        value = 1536
+    return max(0, value)
+
+
+def get_save_prob_map() -> bool:
+    """Save a downsampled probability-map PNG per run for debugging (default off)."""
+    return _flag("DETECTION_SAVE_PROB_MAP", False)
+
+
+def get_border_margin() -> int:
+    """Border pixels zeroed in mask cleanup. Smaller in full-res mode."""
+    raw = _env("DETECTION_BORDER_MARGIN", "")
+    if raw:
+        try:
+            return max(0, min(64, int(raw)))
+        except ValueError:
+            pass
+    return 4 if get_inference_mode() == "fullres_tiled" else 12
+
+
+def summary() -> dict:
+    """Snapshot of effective detection config (for logs and debug output)."""
+    return {
+        "maxSide": get_detection_max_side(),
+        "inferenceMode": get_inference_mode(),
+        "fullresMaxSide": get_fullres_max_side(),
+        "tileSize": get_tile_size(),
+        "tileOverlap": get_tile_overlap(),
+        "multiscale": get_multiscale_scales(),
+        "fusion": get_fusion_mode(),
+        "skipPreblur": get_skip_preblur(),
+        "borderMargin": get_border_margin(),
+    }

app/detection_engine.py

@@ -6,6 +6,8 @@ SIFT+FLANN registration, tile-based + multi-scale processing, Excess Green
 vegetation index, confidence maps, and improved object classification.
 """
 import logging
+from pathlib import Path
+
 import numpy as np
 import cv2
 from PIL import Image
@@ -22,14 +24,8 @@ _log = logging.getLogger(__name__)
 
 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))
+    from .detection_config import get_detection_max_side
+    return get_detection_max_side()
 
 
 def _ensure_rgb_uint8(img_array):
@@ -50,8 +46,13 @@ def _to_float32(img):
     return img.astype(np.float32) / 255.0
 
 
-def preprocess_image(image, max_size=None):
-    """Preprocess image: convert to RGB, limit size, light denoise."""
+def preprocess_image(image, max_size=None, skip_blur=False):
+    """Preprocess image: convert to RGB, limit size, light denoise.
+
+    ``skip_blur`` disables the Gaussian/bilateral denoise so fine change detail
+    is preserved — used by full-resolution tiled inference where the whole point
+    is to keep native sharpness.
+    """
     if max_size is None:
         max_size = get_detection_max_size()
     img_array = np.array(image)
@@ -63,6 +64,9 @@ def preprocess_image(image, max_size=None):
         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)
 
+    if skip_blur:
+        return img_array
+
     # 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)
@@ -311,8 +315,27 @@ def _register_images_ecc_multiscale(img1, img2):
 # 3. Improved radiometric normalization
 # ---------------------------------------------------------------------------
 
+def _match_histogram(src, ref):
+    """Map ``src`` intensities so its histogram matches ``ref`` (single channel)."""
+    src_u = np.clip(src, 0, 255).astype(np.uint8)
+    ref_u = np.clip(ref, 0, 255).astype(np.uint8)
+    src_hist = np.bincount(src_u.ravel(), minlength=256).astype(np.float64)
+    ref_hist = np.bincount(ref_u.ravel(), minlength=256).astype(np.float64)
+    src_cdf = np.cumsum(src_hist) / max(src_u.size, 1)
+    ref_cdf = np.cumsum(ref_hist) / max(ref_u.size, 1)
+    lut = np.interp(src_cdf, ref_cdf, np.arange(256)).astype(np.float32)
+    return lut[src_u]
+
+
 def normalize_radiometry(img1, img2):
-    """Match after image radiometry to before; symmetric CLAHE on L channel."""
+    """Match after image radiometry to before; symmetric CLAHE on L channel.
+
+    CLAHE and histogram matching are env-toggleable (``DETECTION_CLAHE``,
+    ``DETECTION_HIST_MATCH``) so each technique can be A/B benchmarked before
+    being promoted to a default.
+    """
+    from .detection_config import get_enable_clahe, get_hist_match
+
     lab1 = cv2.cvtColor(img1, cv2.COLOR_RGB2LAB).astype(np.float32)
     lab2 = cv2.cvtColor(img2, cv2.COLOR_RGB2LAB).astype(np.float32)
 
@@ -323,11 +346,17 @@ def normalize_radiometry(img1, img2):
         if std2 > 1e-6:
             result[:, :, ch] = (lab2[:, :, ch] - mean2) * (std1 / std2) + mean1
 
-    clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+    if get_hist_match():
+        # Stronger than mean/std matching: align the full L-channel distribution
+        result[:, :, 0] = _match_histogram(result[:, :, 0], lab1[:, :, 0])
+
     lab1_u = cv2.cvtColor(img1, cv2.COLOR_RGB2LAB)
     lab2_u = np.clip(result, 0, 255).astype(np.uint8)
-    lab1_u[:, :, 0] = clahe.apply(lab1_u[:, :, 0])
-    lab2_u[:, :, 0] = clahe.apply(lab2_u[:, :, 0])
+
+    if get_enable_clahe():
+        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+        lab1_u[:, :, 0] = clahe.apply(lab1_u[:, :, 0])
+        lab2_u[:, :, 0] = clahe.apply(lab2_u[:, :, 0])
 
     return cv2.cvtColor(lab1_u, cv2.COLOR_LAB2RGB), cv2.cvtColor(lab2_u, cv2.COLOR_LAB2RGB)
 
@@ -524,6 +553,22 @@ def compute_lbp(gray, radius=1, n_points=8):
     return lbp / n_points
 
 
+def _prob_map_stats(score) -> dict:
+    """Summary stats of a [0,1] probability/score map for threshold tuning."""
+    if score is None or score.size == 0:
+        return {}
+    s = score.astype(np.float32)
+    return {
+        "min": round(float(s.min()), 4),
+        "max": round(float(s.max()), 4),
+        "mean": round(float(s.mean()), 4),
+        "std": round(float(s.std()), 4),
+        "p50": round(float(np.percentile(s, 50)), 4),
+        "p90": round(float(np.percentile(s, 90)), 4),
+        "p99": round(float(np.percentile(s, 99)), 4),
+    }
+
+
 def _hysteresis_threshold(score, high_thr, low_thr):
     """Two-level (hysteresis) thresholding on a [0,1] score map.
 
@@ -937,9 +982,14 @@ def _resolve_classification(scores, diff, feat_a):
     return best, conf
 
 
-def ai_deep_learning_method(img1, img2, sensitivity=0.5, registration_ok=True):
+def ai_deep_learning_method(img1, img2, sensitivity=0.5, registration_ok=True,
+                            dl_score_override=None):
     """
     Dual-engine: AdaptFormer + classical fusion with confidence-pruned union.
+
+    ``dl_score_override`` lets callers supply a precomputed deep score map (e.g.
+    full-resolution windowed inference) instead of running AdaptFormer on the
+    working-resolution arrays.
     """
     from .model_inference import is_model_available, predict_change_mask
 
@@ -948,7 +998,14 @@ def ai_deep_learning_method(img1, img2, sensitivity=0.5, registration_ok=True):
     model_ok = False
     threshold = 0.30 + (1.0 - float(np.clip(sensitivity, 0, 1))) * 0.22
 
-    if is_model_available():
+    if dl_score_override is not None:
+        dl_score = dl_score_override.astype(np.float32)
+        if dl_score.shape != img1.shape[:2]:
+            dl_score = cv2.resize(dl_score, (img1.shape[1], img1.shape[0]),
+                                  interpolation=cv2.INTER_LINEAR)
+        model_mask = (dl_score >= threshold).astype(np.uint8) * 255
+        model_ok = True
+    elif is_model_available():
         try:
             model_mask, dl_score = predict_change_mask(img1, img2, threshold=threshold)
             model_ok = dl_score is not None
@@ -961,18 +1018,33 @@ def ai_deep_learning_method(img1, img2, sensitivity=0.5, registration_ok=True):
     if model_ok and dl_score is not None:
         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)
+
+        from .detection_config import get_fusion_mode
+        fusion_mode = get_fusion_mode()
+        if fusion_mode == "hysteresis":
+            # Confidence-gated hysteresis fusion keeps complete change blobs
+            # while pruning isolated weak responses (better recall on big blobs).
+            combined, final_score, fuse_dbg = fuse_dl_and_classical(
+                dl_score, classical_score, img1, img2, sensitivity=sensitivity)
+        else:
+            combined = _smart_union_fusion(
+                model_mask, rule_mask, dl_score, classical_score, sensitivity=sensitivity)
+            combined = _clean_mask(combined, sensitivity=sensitivity)
+            final_score = np.maximum(dl_score, classical_score)
+            fuse_dbg = {}
         debug = {
             "method": "AI-Based Deep Learning (AdaptFormer + confidence union)",
             "model": "adaptformer-levir-cd",
-            "fusion": "smart_union",
+            "fusion": fusion_mode,
             "threshold_used": int(threshold * 255),
             "sensitivity": float(sensitivity),
             "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)),
+            "fusion_debug": fuse_dbg,
+            "dl_score_source": "windowed_fullres" if dl_score_override is not None else "tiled",
+            "probabilityMapStats": _prob_map_stats(final_score),
+            "_score_map": final_score.astype(np.float32),
         }
         return combined, debug
 
@@ -1129,7 +1201,7 @@ ALIGNMENT_WARNING_MSG = (
 # 11. Robust post-processing
 # ---------------------------------------------------------------------------
 
-def _clean_mask(mask, sensitivity=0.5, border_margin=12):
+def _clean_mask(mask, sensitivity=0.5, border_margin=None):
     """
     Robust morphological cleaning:
     1. Zero-out border pixels (registration artifacts)
@@ -1139,7 +1211,13 @@ def _clean_mask(mask, sensitivity=0.5, border_margin=12):
     5. Fill holes inside regions
     6. Erode-then-dilate to break thin noise bridges
     7. Connected-component area + circularity filtering
+
+    ``border_margin`` defaults to the env-configured value (smaller in full-res
+    mode so genuine edge changes are not discarded).
     """
+    if border_margin is None:
+        from .detection_config import get_border_margin
+        border_margin = get_border_margin()
     mask = mask.copy()
     h, w = mask.shape[:2]
 
@@ -2639,16 +2717,57 @@ 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,
-                  max_size=None, on_progress=None):
+                  max_size=None, on_progress=None,
+                  before_path=None, after_path=None):
     """Run full detection pipeline; returns change_mask, result_image, stats, regions."""
+    from .detection_config import (
+        get_inference_mode, get_load_max_side, get_skip_preblur,
+        get_windowed_threshold, get_tile_size, get_tile_overlap,
+    )
+
     def _prog(pct, stage):
         if on_progress:
             on_progress(int(pct), stage)
 
-    ms = max_size or get_detection_max_size()
+    inference_mode = get_inference_mode()
+    skip_blur = get_skip_preblur()
+
+    # Decide whether to stream the deep score from native GeoTIFF windows.
+    # Triggered for very large rasters (native side > threshold) or when loading
+    # the full-res array would blow the memory budget, so peak RAM stays bounded
+    # while the model still sees full-resolution detail.
+    windowed = False
+    if inference_mode == "fullres_tiled" and before_path and after_path:
+        try:
+            from .dda.geotiff_io import read_native_size
+            from .detection_config import get_tile_memory_budget_mb
+            thr = get_windowed_threshold()
+            na = read_native_size(Path(before_path))
+            nb = read_native_size(Path(after_path))
+            if na and nb and na == nb:
+                cap = get_load_max_side()
+                long_side = min(max(na), cap)
+                # ~3 bytes/px/array, two timestamps held in memory at once
+                est_mb = (long_side * long_side * 3 * 2) / (1024 * 1024)
+                budget = get_tile_memory_budget_mb()
+                over_threshold = bool(thr and max(na) > thr)
+                over_budget = bool(budget and est_mb > budget)
+                if over_threshold or over_budget:
+                    windowed = True
+        except Exception as exc:
+            _log.warning("Windowed-size probe failed: %s", exc)
+
+    if inference_mode == "fullres_tiled" and not windowed:
+        # Keep full imagery at the full-res cap and skip denoise.
+        ms = max_size if (max_size and max_size > get_detection_max_size()) else get_load_max_side()
+    else:
+        # Windowed mode keeps the in-memory arrays bounded (registration +
+        # classical run on the preview); detail comes from the streamed score.
+        ms = max_size or get_detection_max_size()
+
     _prog(5, "Preprocessing images")
-    before_array = preprocess_image(before_pil, max_size=ms)
-    after_array = preprocess_image(after_pil, max_size=ms)
+    before_array = preprocess_image(before_pil, max_size=ms, skip_blur=skip_blur)
+    after_array = preprocess_image(after_pil, max_size=ms, skip_blur=skip_blur)
 
     registration_ok = False
     reg_meta = {}
@@ -2664,12 +2783,33 @@ def run_detection(before_pil, after_pil, method="AI-Based Deep Learning",
     if enable_registration and not registration_ok:
         alignment_warning = ALIGNMENT_WARNING_MSG
 
+    dl_score_override = None
+    if windowed and method in ("AI-Based Deep Learning", "Hybrid AI"):
+        try:
+            from .model_inference import is_model_available, predict_change_score_windowed
+            if is_model_available():
+                _prog(45, "Full-res tiled inference")
+                out_h, out_w = before_array.shape[:2]
+
+                def _win_prog(frac):
+                    _prog(45 + int(frac * 5), "Full-res tiled inference")
+
+                dl_score_override = predict_change_score_windowed(
+                    before_path, after_path, out_h, out_w,
+                    tile_size=get_tile_size(), overlap=get_tile_overlap(),
+                    on_progress=_win_prog,
+                )
+        except Exception as exc:
+            _log.warning("Windowed inference failed, falling back to in-memory: %s", exc)
+            dl_score_override = None
+
     _prog(50, f"Running {method}")
     if method == "AI-Based Deep Learning":
         change_mask, threshold_debug = ai_deep_learning_method(
             before_array, after_array,
             sensitivity=detection_sensitivity,
             registration_ok=registration_ok,
+            dl_score_override=dl_score_override,
         )
     elif method == "Image Difference":
         change_mask, threshold_debug = image_difference_method(
@@ -2696,6 +2836,22 @@ def run_detection(before_pil, after_pil, method="AI-Based Deep Learning",
             registration_ok=registration_ok,
         )
 
+    # Pull the (numpy) probability map out of the debug dict so the returned
+    # threshold_debug stays JSON-serializable; stash it privately in stats for
+    # optional probability-PNG export downstream.
+    score_map = None
+    if isinstance(threshold_debug, dict):
+        score_map = threshold_debug.pop("_score_map", None)
+        from .detection_config import (
+            get_tile_size as _gts, get_tile_overlap as _gto,
+            get_multiscale_scales as _gms, get_fusion_mode as _gfm,
+        )
+        threshold_debug["inferenceMode"] = inference_mode
+        threshold_debug["windowed"] = bool(windowed)
+        threshold_debug["fusionMode"] = _gfm()
+        threshold_debug["tileConfig"] = {"tileSize": _gts(), "overlap": _gto(),
+                                         "multiscale": _gms()}
+
     total_pixels = int(change_mask.shape[0] * change_mask.shape[1])
     changed_pixels_ratio = (
         float(np.sum(change_mask > 127)) / float(total_pixels) if total_pixels else 0.0
@@ -2758,7 +2914,12 @@ def run_detection(before_pil, after_pil, method="AI-Based Deep Learning",
             "enable_normalization": bool(enable_normalization),
             "registration_ok": bool(registration_ok),
             "registration": reg_meta,
+            "inference_mode": inference_mode,
+            "windowed": bool(windowed),
+            "working_resolution": [int(before_array.shape[1]), int(before_array.shape[0])],
         },
     }
+    if score_map is not None:
+        stats["_score_map"] = score_map  # numpy; not serialized, consumed downstream
 
     return change_mask, result_image, stats, change_regions

app/evaluation/__init__.py

@@ -0,0 +1,4 @@
+"""Evaluation utilities for change detection (binary-mask metrics)."""
+from .metrics import binary_metrics, confusion_counts
+
+__all__ = ["binary_metrics", "confusion_counts"]

app/evaluation/metrics.py

@@ -0,0 +1,79 @@
+"""Binary change-mask evaluation metrics.
+
+All functions take boolean / 0-or-255 / 0-or-1 masks of identical shape and
+return plain Python floats so results are easy to log and serialize. These are
+the standard pixel-wise change-detection metrics: IoU, Dice/F1, precision,
+recall, pixel accuracy and the false-positive / false-negative rates.
+"""
+from __future__ import annotations
+
+from dataclasses import asdict, dataclass
+
+import numpy as np
+
+
+def _to_bool(mask: np.ndarray) -> np.ndarray:
+    arr = np.asarray(mask)
+    if arr.dtype == bool:
+        return arr
+    return arr > (127 if arr.max() > 1 else 0)
+
+
+@dataclass
+class ConfusionCounts:
+    tp: int
+    fp: int
+    fn: int
+    tn: int
+
+
+def confusion_counts(pred: np.ndarray, gt: np.ndarray) -> ConfusionCounts:
+    """Pixel-wise true/false positive/negative counts for two binary masks."""
+    p = _to_bool(pred)
+    g = _to_bool(gt)
+    if p.shape != g.shape:
+        raise ValueError(f"shape mismatch: pred {p.shape} vs gt {g.shape}")
+    tp = int(np.sum(p & g))
+    fp = int(np.sum(p & ~g))
+    fn = int(np.sum(~p & g))
+    tn = int(np.sum(~p & ~g))
+    return ConfusionCounts(tp=tp, fp=fp, fn=fn, tn=tn)
+
+
+def _safe_div(num: float, den: float) -> float:
+    return float(num) / float(den) if den else 0.0
+
+
+def binary_metrics(pred: np.ndarray, gt: np.ndarray) -> dict:
+    """Return IoU, Dice/F1, precision, recall, accuracy, FPR and FNR.
+
+    Edge case: when ground truth has no positive pixels and the prediction is
+    also empty, IoU/Dice/precision/recall are defined as 1.0 (perfect).
+    """
+    c = confusion_counts(pred, gt)
+    tp, fp, fn, tn = c.tp, c.fp, c.fn, c.tn
+
+    if (tp + fp + fn) == 0:
+        precision = recall = iou = dice = 1.0
+    else:
+        precision = _safe_div(tp, tp + fp)
+        recall = _safe_div(tp, tp + fn)
+        iou = _safe_div(tp, tp + fp + fn)
+        dice = _safe_div(2 * tp, 2 * tp + fp + fn)
+
+    f1 = _safe_div(2 * precision * recall, precision + recall) if (precision + recall) else dice
+    accuracy = _safe_div(tp + tn, tp + fp + fn + tn)
+    fpr = _safe_div(fp, fp + tn)
+    fnr = _safe_div(fn, fn + tp)
+
+    return {
+        "iou": round(iou, 4),
+        "dice": round(dice, 4),
+        "f1": round(f1, 4),
+        "precision": round(precision, 4),
+        "recall": round(recall, 4),
+        "pixelAccuracy": round(accuracy, 4),
+        "falsePositiveRate": round(fpr, 4),
+        "falseNegativeRate": round(fnr, 4),
+        "counts": asdict(c),
+    }

app/model_inference.py

@@ -169,76 +169,140 @@ def _unflip_map(score, op):
 
 
 def _infer_score_map(img1, img2):
-    """Single-pass tiled inference returning a float32 change-probability map at (h, w)."""
+    """Single-pass tiled inference returning a float32 change-probability map at (h, w).
+
+    The model always sees its native 256px patches; the shared tiler handles
+    padding, sliding windows and cosine blending so stitching stays consistent
+    across every deep model in the project.
+    """
     torch, _, _ = _try_import()
     model, processor = _load_model()
     from PIL import Image as PILImage
 
-    h, w = img1.shape[:2]
-    tile = _TILE_SIZE
-    overlap = tile // 4
-    stride = tile - overlap
+    from .cd_models.model_utils import tiled_score_map
+    from .detection_config import get_tile_batch
+
+    def _score_tile(t1, t2):
+        pil1 = PILImage.fromarray(t1)
+        pil2 = PILImage.fromarray(t2)
+        inputs = processor(images=(pil1, pil2), return_tensors="pt")
+        inputs = {k: v.to(_DEVICE) for k, v in inputs.items()}
+        outputs = model(**inputs)
+        logits = outputs.logits
+        return _logits_to_change_prob(logits, torch).cpu().numpy()
+
+    def _score_batch(pairs):
+        # Stack each pair's processed tensors along the batch dim for one forward
+        # pass. Only used when the model's output batch dim matches the number of
+        # input pairs; otherwise fall back to correct per-tile scoring.
+        n = len(pairs)
+        try:
+            per_pair = [
+                processor(images=(PILImage.fromarray(t1), PILImage.fromarray(t2)),
+                          return_tensors="pt")
+                for t1, t2 in pairs
+            ]
+            keys = per_pair[0].keys()
+            per_pair_bs = per_pair[0][next(iter(keys))].shape[0]
+            stacked = {k: torch.cat([p[k] for p in per_pair], dim=0).to(_DEVICE)
+                       for k in keys}
+            outputs = model(**stacked)
+            logits = outputs.logits
+            if logits.shape[0] != n * per_pair_bs:
+                raise RuntimeError("unexpected batched logits layout")
+            group = per_pair_bs
+            return [
+                _logits_to_change_prob(logits[i * group:(i + 1) * group], torch).cpu().numpy()
+                for i in range(n)
+            ]
+        except Exception as exc:
+            logger.warning("Batched tile inference failed (%s); using per-tile", exc)
+            return [_score_tile(t1, t2) for t1, t2 in pairs]
 
-    pad_h = (tile - h % tile) % tile
-    pad_w = (tile - w % tile) % tile
-    if pad_h or pad_w:
-        img1 = np.pad(img1, ((0, pad_h), (0, pad_w), (0, 0)), mode="reflect")
-        img2 = np.pad(img2, ((0, pad_h), (0, pad_w), (0, 0)), mode="reflect")
+    batch = get_tile_batch()
+    with torch.no_grad():
+        return tiled_score_map(_score_tile, img1, img2,
+                               tile_size=_TILE_SIZE, overlap=_TILE_SIZE // 4,
+                               score_batch_fn=_score_batch if batch > 1 else None,
+                               batch=batch)
 
-    ph, pw = img1.shape[:2]
-    score_sum = np.zeros((ph, pw), dtype=np.float32)
-    count = np.zeros((ph, pw), dtype=np.float32)
 
-    ramp = np.linspace(0, 1, overlap)
-    flat = np.ones(tile - 2 * overlap)
-    profile = np.concatenate([ramp, flat, ramp[::-1]])
-    weight_2d = np.outer(profile, profile).astype(np.float32)
+def _count_windows(full_h, full_w, tile_size, overlap):
+    step = max(1, int(round(tile_size * (1.0 - overlap))))
+    ny = len(range(0, max(1, full_h - tile_size + 1), step)) + (1 if full_h > tile_size else 0)
+    nx = len(range(0, max(1, full_w - tile_size + 1), step)) + (1 if full_w > tile_size else 0)
+    return max(1, ny) * max(1, nx)
 
-    with torch.no_grad():
-        for y0 in range(0, ph - tile + 1, stride):
-            for x0 in range(0, pw - tile + 1, stride):
-                t1 = np.ascontiguousarray(img1[y0:y0+tile, x0:x0+tile])
-                t2 = np.ascontiguousarray(img2[y0:y0+tile, x0:x0+tile])
 
-                pil1 = PILImage.fromarray(t1)
-                pil2 = PILImage.fromarray(t2)
+def predict_change_score_windowed(path_a, path_b, out_h, out_w,
+                                  tile_size=512, overlap=0.25, on_progress=None):
+    """Build a change-probability map from two large GeoTIFFs via disk windows.
 
-                inputs = processor(images=(pil1, pil2), return_tensors="pt")
-                inputs = {k: v.to(_DEVICE) for k, v in inputs.items()}
+    Reads paired native-resolution windows (so the model sees full detail),
+    scores each with AdaptFormer, then accumulates into a bounded
+    ``(out_h, out_w)`` canvas with cosine blending. Peak memory stays at one
+    native window plus the small output canvas, so 10k+ rasters never OOM.
+    ``on_progress(frac)`` (0..1) is called as windows complete.
+    Returns a float32 score map in [0, 1] at (out_h, out_w).
+    """
+    from .dda.geotiff_io import iter_geotiff_window_pairs, read_native_size
 
-                outputs = model(**inputs)
-                logits = outputs.logits
-                prob_map = _logits_to_change_prob(logits, torch).cpu().numpy()
+    _load_model()
 
-                out_h, out_w = prob_map.shape
-                if out_h != tile or out_w != tile:
-                    prob_map = cv2.resize(prob_map, (tile, tile),
-                                          interpolation=cv2.INTER_LINEAR)
+    score_sum = np.zeros((out_h, out_w), dtype=np.float32)
+    count = np.zeros((out_h, out_w), dtype=np.float32)
+    scale_y = scale_x = None
+
+    total = None
+    native = read_native_size(__import__("pathlib").Path(path_a))
+    if native:
+        total = _count_windows(native[1], native[0], tile_size, overlap)
+    done = 0
+
+    for tile_a, tile_b, y0, x0, full_h, full_w in iter_geotiff_window_pairs(
+            path_a, path_b, tile_size=tile_size, overlap=overlap):
+        if scale_y is None:
+            scale_y = out_h / float(full_h)
+            scale_x = out_w / float(full_w)
+            if total is None:
+                total = _count_windows(full_h, full_w, tile_size, overlap)
+
+        wh, ww = tile_a.shape[:2]
+        score = _infer_score_map(tile_a, tile_b)
+
+        dy0 = int(round(y0 * scale_y))
+        dx0 = int(round(x0 * scale_x))
+        dh = max(1, int(round(wh * scale_y)))
+        dw = max(1, int(round(ww * scale_x)))
+        dy1 = min(out_h, dy0 + dh)
+        dx1 = min(out_w, dx0 + dw)
+        dh, dw = dy1 - dy0, dx1 - dx0
+        if dh <= 0 or dw <= 0:
+            continue
 
-                score_sum[y0:y0+tile, x0:x0+tile] += prob_map * weight_2d
-                count[y0:y0+tile, x0:x0+tile] += weight_2d
+        score_ds = cv2.resize(score, (dw, dh), interpolation=cv2.INTER_AREA)
+        wy = np.hanning(dh + 2)[1:-1] if dh > 2 else np.ones(dh)
+        wx = np.hanning(dw + 2)[1:-1] if dw > 2 else np.ones(dw)
+        weight = np.maximum(np.outer(wy, wx).astype(np.float32), 1e-3)
 
-    count = np.maximum(count, 1e-6)
-    avg_score = score_sum / count
-    return avg_score[:h, :w]
+        score_sum[dy0:dy1, dx0:dx1] += score_ds * weight
+        count[dy0:dy1, dx0:dx1] += weight
 
+        done += 1
+        if on_progress and total:
+            try:
+                on_progress(min(1.0, done / float(total)))
+            except Exception:
+                pass
 
-def predict_change_mask(img1, img2, threshold=0.5):
-    """
-    Run AdaptFormer inference on two RGB numpy arrays (H, W, 3).
-    Averages predictions over test-time augmentation flips (DETECTION_TTA) for
-    higher-accuracy, less boundary-sensitive change maps.
-    Returns (uint8 mask [0 or 255], float32 score map [0-1]).
-    Use threshold > 1.0 to obtain score map only (empty mask).
-    """
-    _load_model()
+    count = np.maximum(count, 1e-6)
+    return score_sum / count
 
-    if img1.shape != img2.shape:
-        img2 = cv2.resize(img2, (img1.shape[1], img1.shape[0]))
 
+def _predict_score_tta(img1, img2):
+    """TTA-averaged change score for one (already same-size) image pair."""
     h, w = img1.shape[:2]
     ops = _resolve_tta_ops()
-
     acc = np.zeros((h, w), dtype=np.float32)
     n = 0
     for op in ops:
@@ -251,10 +315,49 @@ def predict_change_mask(img1, img2, threshold=0.5):
             continue
         acc += _unflip_map(s, op)
         n += 1
-
     if n == 0:
         raise RuntimeError("AdaptFormer inference produced no predictions")
-    avg_score = acc / float(n)
+    return acc / float(n)
+
+
+def predict_change_mask(img1, img2, threshold=0.5):
+    """
+    Run AdaptFormer inference on two RGB numpy arrays (H, W, 3).
+    Averages predictions over test-time augmentation flips (DETECTION_TTA) and,
+    when DETECTION_MULTISCALE is set, fuses scores across scales (max) so both
+    small and large changes are captured.
+    Returns (uint8 mask [0 or 255], float32 score map [0-1]).
+    Use threshold > 1.0 to obtain score map only (empty mask).
+    """
+    _load_model()
+
+    if img1.shape != img2.shape:
+        img2 = cv2.resize(img2, (img1.shape[1], img1.shape[0]))
+
+    h, w = img1.shape[:2]
+
+    from .detection_config import get_multiscale_scales
+    scales = get_multiscale_scales()
+
+    if not scales:
+        avg_score = _predict_score_tta(img1, img2)
+    else:
+        fused = None
+        for scale in scales:
+            if scale == 1.0:
+                s1, s2 = img1, img2
+            else:
+                nh = max(64, int(round(h * scale)))
+                nw = max(64, int(round(w * scale)))
+                interp = cv2.INTER_AREA if scale < 1.0 else cv2.INTER_CUBIC
+                s1 = cv2.resize(img1, (nw, nh), interpolation=interp)
+                s2 = cv2.resize(img2, (nw, nh), interpolation=interp)
+            score = _predict_score_tta(s1, s2)
+            if score.shape != (h, w):
+                score = cv2.resize(score, (w, h), interpolation=cv2.INTER_LINEAR)
+            # Max fusion favors recall on small structures that only one scale sees
+            fused = score if fused is None else np.maximum(fused, score)
+        avg_score = fused
 
     mask = (avg_score >= threshold).astype(np.uint8) * 255
     return mask, avg_score

scripts/validate_detection.py

@@ -1,7 +1,18 @@
 """
-Lightweight validation for the change detection pipeline.
-Run from change_detection_webapp: python scripts/validate_detection.py
+Lightweight validation + accuracy benchmark for the change detection pipeline.
+
+Run from change_detection_webapp:
+    python scripts/validate_detection.py            # unit checks
+    python scripts/validate_detection.py --benchmark # synthetic IoU/Dice/F1 report
+    python scripts/validate_detection.py --benchmark --out runs/eval  # + comparison PNGs
+
+Benchmarks run on synthetic pairs with known ground-truth change masks, so they
+work even without labeled imagery (per project decision: synthetic + review
+labels for now). The same harness is used to A/B preprocessing and fusion
+toggles by setting the relevant DETECTION_* env vars before running.
 """
+import argparse
+import json
 import sys
 from pathlib import Path
 
@@ -16,6 +27,7 @@ from app.detection_engine import (  # noqa: E402
     run_detection,
     fuse_dl_and_classical,
 )
+from app.evaluation.metrics import binary_metrics  # noqa: E402
 
 
 def test_registration_identical_pair():
@@ -69,7 +81,105 @@ def test_run_detection_synthetic():
     print("  run_detection: change%=", f"{ratio:.2f}", "regions=", len(regions))
 
 
+# ---------------------------------------------------------------------------
+# Synthetic benchmark suite (known ground-truth masks)
+# ---------------------------------------------------------------------------
+
+def _base_scene(size=384, seed=0):
+    """A textured pseudo-aerial scene so registration/feature matching has signal."""
+    rng = np.random.default_rng(seed)
+    img = rng.integers(40, 200, (size, size, 3), dtype=np.uint8)
+    img = np.array(Image.fromarray(img).resize((size, size)))
+    # A few stable structures (roads / fields) common to both timestamps
+    img[:, size // 3: size // 3 + 6] = [90, 90, 90]
+    img[size // 2: size // 2 + 6, :] = [110, 100, 80]
+    return img
+
+
+def _case_inserted_buildings(size=384):
+    before = _base_scene(size, seed=1)
+    after = before.copy()
+    gt = np.zeros((size, size), dtype=np.uint8)
+    boxes = [(60, 70, 50, 40), (220, 90, 60, 55), (150, 250, 70, 45)]
+    for (x, y, w, h) in boxes:
+        after[y:y + h, x:x + w] = [205, 200, 190]
+        gt[y:y + h, x:x + w] = 255
+    return before, after, gt, "inserted_buildings"
+
+
+def _case_brightness_only(size=384):
+    # Global illumination change with NO structural change -> GT empty, expect low FP.
+    before = _base_scene(size, seed=2)
+    after = np.clip(before.astype(np.float32) * 1.18 + 12, 0, 255).astype(np.uint8)
+    gt = np.zeros((size, size), dtype=np.uint8)
+    return before, after, gt, "brightness_only"
+
+
+def _case_misaligned_change(size=384):
+    before = _base_scene(size, seed=3)
+    shifted = np.roll(np.roll(before, 6, axis=0), 4, axis=1)
+    after = shifted.copy()
+    gt = np.zeros((size, size), dtype=np.uint8)
+    x, y, w, h = 180, 160, 80, 60
+    after[y:y + h, x:x + w] = [210, 60, 60]
+    gt[y:y + h, x:x + w] = 255
+    return before, after, gt, "misaligned_change"
+
+
+def _save_comparison(out_dir: Path, name: str, before, after, pred_mask, gt):
+    out_dir.mkdir(parents=True, exist_ok=True)
+    h, w = gt.shape
+    pred = (pred_mask > 127).astype(np.uint8) * 255
+    overlay = after.copy()
+    overlay[pred > 0] = (0.45 * overlay[pred > 0] + 0.55 * np.array([255, 40, 40])).astype(np.uint8)
+    diff = np.zeros((h, w, 3), dtype=np.uint8)
+    diff[(pred > 0) & (gt > 0)] = [0, 200, 0]      # true positive
+    diff[(pred > 0) & (gt == 0)] = [255, 0, 0]     # false positive
+    diff[(pred == 0) & (gt > 0)] = [0, 0, 255]     # false negative
+    panels = [
+        before, after,
+        np.dstack([gt] * 3), overlay, diff,
+    ]
+    strip = np.concatenate([np.asarray(p, dtype=np.uint8) for p in panels], axis=1)
+    Image.fromarray(strip).save(out_dir / f"{name}.png")
+
+
+def benchmark_synthetic(out_dir: Path | None = None, sensitivity=0.5):
+    cases = [_case_inserted_buildings(), _case_brightness_only(), _case_misaligned_change()]
+    report = {}
+    print("\nSynthetic benchmark (IoU / Dice / F1 / Precision / Recall):")
+    for before, after, gt, name in cases:
+        mask, _img, stats, regions = run_detection(
+            Image.fromarray(before), Image.fromarray(after),
+            method="AI-Based Deep Learning",
+            enable_registration=True, enable_normalization=True,
+            detection_sensitivity=sensitivity,
+        )
+        if mask.shape != gt.shape:
+            from cv2 import resize, INTER_NEAREST
+            mask = resize(mask, (gt.shape[1], gt.shape[0]), interpolation=INTER_NEAREST)
+        m = binary_metrics(mask, gt)
+        report[name] = {"metrics": m, "regions": len(regions),
+                        "changePct": round(stats["change_percentage"], 3)}
+        print(f"  {name:20s} IoU={m['iou']:.3f} Dice={m['dice']:.3f} "
+              f"F1={m['f1']:.3f} P={m['precision']:.3f} R={m['recall']:.3f} "
+              f"FPR={m['falsePositiveRate']:.3f}")
+        if out_dir is not None:
+            _save_comparison(out_dir, name, before, after, mask, gt)
+
+    if out_dir is not None:
+        (out_dir / "metrics.json").write_text(json.dumps(report, indent=2), encoding="utf-8")
+        print(f"\n  Wrote comparison images + metrics.json to {out_dir}")
+    return report
+
+
 def main():
+    parser = argparse.ArgumentParser(description="Validate + benchmark change detection")
+    parser.add_argument("--benchmark", action="store_true", help="run synthetic accuracy benchmark")
+    parser.add_argument("--out", type=str, default="", help="dir for comparison images + metrics.json")
+    parser.add_argument("--sensitivity", type=float, default=0.5)
+    args = parser.parse_args()
+
     print("validate_detection.py")
     test_registration_identical_pair()
     test_registration_with_shift()
@@ -77,6 +187,10 @@ def main():
     test_run_detection_synthetic()
     print("All checks passed.")
 
+    if args.benchmark:
+        out_dir = Path(args.out).resolve() if args.out else None
+        benchmark_synthetic(out_dir=out_dir, sensitivity=args.sensitivity)
+
 
 if __name__ == "__main__":
     main()

static/js/dda/compare.js

@@ -383,7 +383,8 @@ async function runDetectionWithFallback(form) {
   } catch (err) {
     const msg = String(err.message || '');
     const useSync = msg.includes('Not Found') || msg.includes('404')
-      || msg.includes('503') || msg.includes('409') || msg.includes('busy');
+      || msg.includes('503') || msg.includes('409') || msg.includes('busy')
+      || msg.includes('Internal Server Error') || msg.includes('NOT NULL');
     if (!useSync) throw err;
     return runSyncDetectionWithProgress(form);
   }

templates/index_dda.html

@@ -326,7 +326,7 @@
   <script src="/static/js/dda/tree.js?v=2"></script>
   <script src="/static/js/dda/library.js?v=10"></script>
   <script src="/static/js/dda/result.js?v=7"></script>
-  <script src="/static/js/dda/compare.js?v=11"></script>
+  <script src="/static/js/dda/compare.js?v=13"></script>
   <script src="/static/js/dda/reports.js?v=4"></script>
   <script src="/static/js/dda/notifications.js?v=1"></script>
 </body>