Revert "Add zone-aware library organization for dev DDA uploads."

This reverts commit 96454a961b54b82f2066031bdb6464fde03bcb75.

DEPLOYMENT.md

@@ -133,7 +133,7 @@ Set these in each Space’s **Settings → Repository secrets / Variables** if n
 | Variable | Purpose |
 |----------|---------|
 | `APP_MODE` | Set to `dda` on **satdetect-dev** only (enables DDA library UI) |
-| `LOCAL_LIBRARY_ROOT` | Path to library root (default: `library_sources/` or `data/library_sources/` on HF) |
+| `LOCAL_LIBRARY_ROOT` | Path to year folders (default: `library_sources/` in project) |
 | `MAX_GEOTIFF_MB` | Library GeoTIFF upload cap (default **5120** = 5 GB on dev) |
 | `MAX_IMAGE_MB` | PNG/JPEG library cap (default 50 MB) |
 | `SECRET_KEY` | Optional legacy JWT setting (login disabled) |
@@ -148,44 +148,20 @@ Dev Space can omit `SECRET_KEY` (login is disabled on both Spaces).
 
 ---
 
-## Library folder layout (zone-aware)
-
-Images are stored under a **zone → folder → year** hierarchy:
-
-```text
-library_sources/
-  central_delhi/
-    site_a/
-      2025/
-        image.tif
-  _unassigned/
-    legacy/
-      2025/
-        old_image.tif
-```
-
-- **Zones** and **folders** are managed in the UI (admin: **Manage** in the library sidebar).
-- **Upload** requires selecting zone, folder, and year (HF dev and local upload form).
-- On first startup after upgrade, flat `library_sources/YEAR/` files are moved to `_unassigned/legacy/YEAR/`.
-- Slugs on disk (e.g. `central_delhi`) are stable; renaming a zone/folder in the UI changes the display label only.
-
----
-
 ## UAT checklist (satdetect-dev)
 
 Run before promoting any DDA feature to production:
 
 1. **Health** — `GET /health` returns `status: ok`, `appMode: dda`, `dda.libraryImages` ≥ 0
-2. **Library** — Create zone + folder (admin); upload GeoTIFF with zone/folder/year; tree and grid show breadcrumb; Refresh works
-3. **Legacy** — Old flat year files appear under Unassigned; Assign location moves file to chosen zone/folder/year
-4. **Compare** — Select T1/T2; Run Detection completes (async job or sync fallback)
-5. **Viewer** — Slider / T1 / T2 / Overlay modes; click region to locate
-6. **Review** — Confirm and False Positive; Export confirmed CSV; Submit confirmed
-7. **Reports** — PDF download; `/dda/reports/{id}` page; email link (if SMTP configured)
-8. **Session isolation** — Two browsers see separate history (per-session cookie)
-9. **Admin** — `GET /api/dda/admin/status` (analyst+); stale job reconcile after restart
-10. **Training export** — Mark false positives → `GET /api/dda/training/export` (admin or export key)
-11. **Security** — Path traversal blocked (`../` in library path); upload size limit enforced
+2. **Library** — Upload GeoTIFF to year folder; Refresh shows image; thumb loads
+3. **Compare** — Select T1/T2; Run Detection completes (async job or sync fallback)
+4. **Viewer** — Slider / T1 / T2 / Overlay modes; click region to locate
+5. **Review** — Confirm and False Positive; Export confirmed CSV; Submit confirmed
+6. **Reports** — PDF download; `/dda/reports/{id}` page; email link (if SMTP configured)
+7. **Session isolation** — Two browsers see separate history (per-session cookie)
+8. **Admin** — `GET /api/dda/admin/status` (analyst+); stale job reconcile after restart
+9. **Training export** — Mark false positives → `GET /api/dda/training/export` (admin or export key)
+10. **Security** — Path traversal blocked (`../` in library path); upload size limit enforced
 
 Sign-off: DDA stakeholder approves sample runs on dev Space before any push to `satdetect` production.
 

app/dda/bootstrap.py

@@ -4,9 +4,8 @@ from fastapi import FastAPI
 from sqlalchemy import text as sa_text
 
 from ..database import engine
-from .config import IS_DDA_MODE, ensure_library_dirs, is_hf_hosted
+from .config import IS_DDA_MODE, ensure_library_dirs, ensure_local_year_folders, is_hf_hosted
 from .admin_routes import router as admin_router
-from .hierarchy_routes import router as hierarchy_router
 from .jobs_routes import router as jobs_router
 from .library_routes import router as library_router
 from .local_routes import router as local_router
@@ -24,13 +23,12 @@ def init_dda_database():
     if not IS_DDA_MODE:
         return
     ensure_library_dirs()
+    ensure_local_year_folders()
     try:
         with engine.connect() as conn:
             for stmt in (
                 "ALTER TABLE users ADD COLUMN role VARCHAR(32) DEFAULT 'analyst'",
                 "ALTER TABLE detection_runs ADD COLUMN after_full_path VARCHAR(512) DEFAULT ''",
-                "ALTER TABLE dda_zones ADD COLUMN slug VARCHAR(64)",
-                "ALTER TABLE dda_villages ADD COLUMN slug VARCHAR(64)",
             ):
                 try:
                     conn.execute(sa_text(stmt))
@@ -45,37 +43,14 @@ def init_dda_database():
                 conn.commit()
             except Exception:
                 conn.rollback()
-            try:
-                conn.execute(sa_text(
-                    "CREATE UNIQUE INDEX IF NOT EXISTS ix_dda_zones_slug ON dda_zones (slug)"
-                ))
-                conn.commit()
-            except Exception:
-                conn.rollback()
     except Exception as exc:
         logger.warning("DDA schema migration skipped: %s", exc)
 
-    from ..database import Base, SessionLocal
-    try:
-        from .models import DdaLocalFileIndex  # noqa: F401
-        Base.metadata.create_all(bind=engine, tables=[DdaLocalFileIndex.__table__])
-    except Exception as exc:
-        logger.warning("DdaLocalFileIndex table create skipped: %s", exc)
-
+    from ..database import SessionLocal
     db = SessionLocal()
     try:
         seed_delhi_hierarchy(db)
         seed_dda_admin(db)
-        from .library_migration import (
-            backfill_slugs,
-            ensure_legacy_zone,
-            ensure_zone_folder_dirs,
-            migrate_legacy_flat_years,
-        )
-        backfill_slugs(db)
-        ensure_legacy_zone(db)
-        migrate_legacy_flat_years(db)
-        ensure_zone_folder_dirs(db)
         from .job_runner import reconcile_stale_jobs
         reconcile_stale_jobs(db)
     finally:
@@ -83,17 +58,11 @@ def init_dda_database():
 
     try:
         from .local_library import library_debug_info, scan_images
-        from ..database import SessionLocal as SL
-        sdb = SL()
-        try:
-            info = library_debug_info(db=sdb)
-            total = len(scan_images(db=sdb))
-        finally:
-            sdb.close()
+        info = library_debug_info()
         logger.info(
             "DDA library ready (hosted=%s): %d images, writable=%s",
             is_hf_hosted(),
-            total,
+            len(scan_images()),
             info.get("roots", [{}])[0].get("path") if info.get("roots") else "?",
         )
     except Exception as exc:
@@ -110,6 +79,5 @@ def setup_dda(app: FastAPI) -> None:
     app.include_router(review_router, prefix="/api/dda", tags=["dda-review"])
     app.include_router(training_router, prefix="/api/dda", tags=["dda-training"])
     app.include_router(admin_router, prefix="/api/dda", tags=["dda-admin"])
-    app.include_router(hierarchy_router, prefix="/api/dda", tags=["dda-hierarchy"])
     app.include_router(local_router, prefix="/api/dda", tags=["dda-local"])
-    logger.info("APP_MODE=dda — DDA routes enabled (library, jobs, reports, review, training, admin, hierarchy, local)")
+    logger.info("APP_MODE=dda — DDA routes enabled (library, jobs, reports, review, training, admin, local)")

app/dda/hierarchy_routes.py

@@ -1,253 +0,0 @@
-"""CRUD for zone/folder library hierarchy."""
-from __future__ import annotations
-
-import logging
-from typing import Optional
-
-from fastapi import APIRouter, Depends, HTTPException
-from pydantic import BaseModel, Field
-from sqlalchemy.orm import Session
-
-from ..database import get_db
-from ..models import User
-from .config import IS_DDA_MODE, get_writable_library_root
-from .dda_auth import current_dda_user, get_user_role, require_min_role
-from .local_library import count_files_in_folder, count_files_in_zone, scan_tree
-from .models import DdaLocalFileIndex, DdaVillage, DdaZone
-from .path_slugs import unique_slug, validate_path_segment
-
-logger = logging.getLogger(__name__)
-router = APIRouter()
-
-
-def _require_dda():
-    if not IS_DDA_MODE:
-        raise HTTPException(status_code=404, detail="DDA mode is not enabled")
-
-
-class ZoneCreateBody(BaseModel):
-    name: str = Field(..., min_length=1, max_length=128)
-
-
-class ZonePatchBody(BaseModel):
-    name: str = Field(..., min_length=1, max_length=128)
-
-
-class FolderCreateBody(BaseModel):
-    name: str = Field(..., min_length=1, max_length=128)
-
-
-class FolderPatchBody(BaseModel):
-    name: str = Field(..., min_length=1, max_length=128)
-
-
-class YearCreateBody(BaseModel):
-    year: int = Field(..., ge=1990, le=2100)
-
-
-def _zone_dict(zone: DdaZone) -> dict:
-    return {"id": zone.id, "name": zone.name, "slug": zone.slug, "mode": zone.mode}
-
-
-def _folder_dict(folder: DdaVillage) -> dict:
-    return {"id": folder.id, "zoneId": folder.zone_id, "name": folder.name, "slug": folder.slug}
-
-
-def _existing_zone_slugs(db: Session) -> set:
-    return {z.slug for z in db.query(DdaZone).filter(DdaZone.slug.isnot(None)).all() if z.slug}
-
-
-def _existing_folder_slugs(db: Session, zone_id: int) -> set:
-    return {
-        f.slug for f in db.query(DdaVillage).filter(
-            DdaVillage.zone_id == zone_id, DdaVillage.slug.isnot(None)
-        ).all() if f.slug
-    }
-
-
-@router.get("/me")
-def dda_me(user: User = Depends(current_dda_user), db: Session = Depends(get_db)):
-    _require_dda()
-    return {"userId": user.id, "role": get_user_role(db, user), "email": user.email}
-
-
-@router.get("/hierarchy/tree")
-def hierarchy_tree(db: Session = Depends(get_db), user: User = Depends(current_dda_user)):
-    _require_dda()
-    return scan_tree(db)
-
-
-@router.post("/hierarchy/zones")
-def create_zone(
-    body: ZoneCreateBody,
-    db: Session = Depends(get_db),
-    user: User = Depends(current_dda_user),
-):
-    _require_dda()
-    require_min_role(user, db, "admin")
-    name = body.name.strip()
-    if db.query(DdaZone).filter(DdaZone.name == name).first():
-        raise HTTPException(status_code=400, detail="Zone name already exists")
-    slug = unique_slug(name, _existing_zone_slugs(db))
-    if not validate_path_segment(slug):
-        raise HTTPException(status_code=400, detail="Could not derive a valid folder slug")
-    zone = DdaZone(name=name, slug=slug, mode="admin")
-    db.add(zone)
-    db.commit()
-    db.refresh(zone)
-    root = get_writable_library_root()
-    (root / slug).mkdir(parents=True, exist_ok=True)
-    logger.info("Created zone %s (%s)", name, slug)
-    return {"zone": _zone_dict(zone)}
-
-
-@router.patch("/hierarchy/zones/{zone_id}")
-def patch_zone(
-    zone_id: int,
-    body: ZonePatchBody,
-    db: Session = Depends(get_db),
-    user: User = Depends(current_dda_user),
-):
-    _require_dda()
-    require_min_role(user, db, "admin")
-    zone = db.query(DdaZone).filter(DdaZone.id == zone_id).first()
-    if not zone:
-        raise HTTPException(status_code=404, detail="Zone not found")
-    name = body.name.strip()
-    other = db.query(DdaZone).filter(DdaZone.name == name, DdaZone.id != zone_id).first()
-    if other:
-        raise HTTPException(status_code=400, detail="Zone name already exists")
-    zone.name = name
-    db.commit()
-    db.refresh(zone)
-    return {"zone": _zone_dict(zone)}
-
-
-@router.delete("/hierarchy/zones/{zone_id}")
-def delete_zone(
-    zone_id: int,
-    db: Session = Depends(get_db),
-    user: User = Depends(current_dda_user),
-):
-    _require_dda()
-    require_min_role(user, db, "admin")
-    zone = db.query(DdaZone).filter(DdaZone.id == zone_id).first()
-    if not zone:
-        raise HTTPException(status_code=404, detail="Zone not found")
-    if not zone.slug:
-        raise HTTPException(status_code=400, detail="Zone has no slug")
-    root = get_writable_library_root()
-    if count_files_in_zone(root, zone.slug) > 0:
-        raise HTTPException(status_code=400, detail="Zone folder is not empty")
-    indexed = db.query(DdaLocalFileIndex).filter(DdaLocalFileIndex.zone_id == zone_id).count()
-    if indexed > 0:
-        raise HTTPException(status_code=400, detail="Zone has indexed files")
-    zone_dir = root / zone.slug
-    db.delete(zone)
-    db.commit()
-    if zone_dir.exists() and zone_dir.is_dir():
-        try:
-            zone_dir.rmdir()
-        except OSError:
-            pass
-    return {"ok": True}
-
-
-@router.post("/hierarchy/zones/{zone_id}/folders")
-def create_folder(
-    zone_id: int,
-    body: FolderCreateBody,
-    db: Session = Depends(get_db),
-    user: User = Depends(current_dda_user),
-):
-    _require_dda()
-    require_min_role(user, db, "admin")
-    zone = db.query(DdaZone).filter(DdaZone.id == zone_id).first()
-    if not zone or not zone.slug:
-        raise HTTPException(status_code=404, detail="Zone not found")
-    name = body.name.strip()
-    existing = db.query(DdaVillage).filter(DdaVillage.zone_id == zone_id, DdaVillage.name == name).first()
-    if existing:
-        raise HTTPException(status_code=400, detail="Folder name already exists in this zone")
-    slug = unique_slug(name, _existing_folder_slugs(db, zone_id))
-    folder = DdaVillage(zone_id=zone_id, name=name, slug=slug)
-    db.add(folder)
-    db.commit()
-    db.refresh(folder)
-    (get_writable_library_root() / zone.slug / slug).mkdir(parents=True, exist_ok=True)
-    return {"folder": _folder_dict(folder)}
-
-
-@router.patch("/hierarchy/folders/{folder_id}")
-def patch_folder(
-    folder_id: int,
-    body: FolderPatchBody,
-    db: Session = Depends(get_db),
-    user: User = Depends(current_dda_user),
-):
-    _require_dda()
-    require_min_role(user, db, "admin")
-    folder = db.query(DdaVillage).filter(DdaVillage.id == folder_id).first()
-    if not folder:
-        raise HTTPException(status_code=404, detail="Folder not found")
-    name = body.name.strip()
-    other = db.query(DdaVillage).filter(
-        DdaVillage.zone_id == folder.zone_id, DdaVillage.name == name, DdaVillage.id != folder_id
-    ).first()
-    if other:
-        raise HTTPException(status_code=400, detail="Folder name already exists in this zone")
-    folder.name = name
-    db.commit()
-    db.refresh(folder)
-    return {"folder": _folder_dict(folder)}
-
-
-@router.delete("/hierarchy/folders/{folder_id}")
-def delete_folder(
-    folder_id: int,
-    db: Session = Depends(get_db),
-    user: User = Depends(current_dda_user),
-):
-    _require_dda()
-    require_min_role(user, db, "admin")
-    folder = db.query(DdaVillage).filter(DdaVillage.id == folder_id).first()
-    if not folder:
-        raise HTTPException(status_code=404, detail="Folder not found")
-    zone = db.query(DdaZone).filter(DdaZone.id == folder.zone_id).first()
-    if not zone or not zone.slug or not folder.slug:
-        raise HTTPException(status_code=400, detail="Folder has no disk path")
-    root = get_writable_library_root()
-    if count_files_in_folder(root, zone.slug, folder.slug) > 0:
-        raise HTTPException(status_code=400, detail="Folder is not empty")
-    indexed = db.query(DdaLocalFileIndex).filter(DdaLocalFileIndex.folder_id == folder_id).count()
-    if indexed > 0:
-        raise HTTPException(status_code=400, detail="Folder has indexed files")
-    folder_dir = root / zone.slug / folder.slug
-    db.delete(folder)
-    db.commit()
-    if folder_dir.exists() and folder_dir.is_dir():
-        try:
-            folder_dir.rmdir()
-        except OSError:
-            pass
-    return {"ok": True}
-
-
-@router.post("/hierarchy/folders/{folder_id}/years")
-def create_year_folder(
-    folder_id: int,
-    body: YearCreateBody,
-    db: Session = Depends(get_db),
-    user: User = Depends(current_dda_user),
-):
-    _require_dda()
-    require_min_role(user, db, "uploader")
-    folder = db.query(DdaVillage).filter(DdaVillage.id == folder_id).first()
-    if not folder:
-        raise HTTPException(status_code=404, detail="Folder not found")
-    zone = db.query(DdaZone).filter(DdaZone.id == folder.zone_id).first()
-    if not zone or not zone.slug or not folder.slug:
-        raise HTTPException(status_code=400, detail="Folder has no disk path")
-    year_dir = get_writable_library_root() / zone.slug / folder.slug / str(body.year)
-    year_dir.mkdir(parents=True, exist_ok=True)
-    return {"ok": True, "path": f"{zone.slug}/{folder.slug}/{body.year}"}

app/dda/library_migration.py

@@ -1,148 +0,0 @@
-"""One-time library layout migrations and slug backfill."""
-from __future__ import annotations
-
-import logging
-import shutil
-from pathlib import Path
-from typing import Set
-
-from sqlalchemy.orm import Session
-
-from .config import ALLOWED_EXTENSIONS, get_library_roots, get_writable_library_root
-from .models import DdaLocalFileIndex, DdaVillage, DdaZone
-from .path_slugs import slugify, unique_slug
-
-logger = logging.getLogger(__name__)
-
-LEGACY_ZONE_NAME = "Unassigned"
-LEGACY_ZONE_SLUG = "_unassigned"
-LEGACY_FOLDER_NAME = "Legacy"
-LEGACY_FOLDER_SLUG = "legacy"
-
-
-def _is_year_dir(name: str) -> bool:
-    return len(name) == 4 and name.isdigit() and 1990 <= int(name) <= 2100
-
-
-def backfill_slugs(db: Session) -> dict:
-    """Assign slugs to zones/folders missing them."""
-    zone_slugs: Set[str] = set()
-    for zone in db.query(DdaZone).filter(DdaZone.slug.isnot(None)).all():
-        if zone.slug:
-            zone_slugs.add(zone.slug)
-
-    zones_updated = 0
-    for zone in db.query(DdaZone).order_by(DdaZone.id).all():
-        if zone.slug:
-            continue
-        zone.slug = unique_slug(zone.name, zone_slugs)
-        zone_slugs.add(zone.slug)
-        zones_updated += 1
-
-    folders_updated = 0
-    for zone in db.query(DdaZone).all():
-        folder_slugs: Set[str] = set()
-        for folder in db.query(DdaVillage).filter(
-            DdaVillage.zone_id == zone.id, DdaVillage.slug.isnot(None)
-        ).all():
-            if folder.slug:
-                folder_slugs.add(folder.slug)
-        for folder in db.query(DdaVillage).filter(DdaVillage.zone_id == zone.id).order_by(DdaVillage.id).all():
-            if folder.slug:
-                continue
-            folder.slug = unique_slug(folder.name, folder_slugs)
-            folder_slugs.add(folder.slug)
-            folders_updated += 1
-
-    if zones_updated or folders_updated:
-        db.commit()
-    return {"zonesUpdated": zones_updated, "foldersUpdated": folders_updated}
-
-
-def ensure_legacy_zone(db: Session) -> DdaZone:
-    zone = db.query(DdaZone).filter(DdaZone.slug == LEGACY_ZONE_SLUG).first()
-    if not zone:
-        zone = db.query(DdaZone).filter(DdaZone.name == LEGACY_ZONE_NAME).first()
-    if not zone:
-        zone = DdaZone(name=LEGACY_ZONE_NAME, slug=LEGACY_ZONE_SLUG, mode="admin")
-        db.add(zone)
-        db.flush()
-    elif not zone.slug:
-        zone.slug = LEGACY_ZONE_SLUG
-    folder = db.query(DdaVillage).filter(
-        DdaVillage.zone_id == zone.id, DdaVillage.slug == LEGACY_FOLDER_SLUG
-    ).first()
-    if not folder:
-        folder = db.query(DdaVillage).filter(
-            DdaVillage.zone_id == zone.id, DdaVillage.name == LEGACY_FOLDER_NAME
-        ).first()
-    if not folder:
-        folder = DdaVillage(zone_id=zone.id, name=LEGACY_FOLDER_NAME, slug=LEGACY_FOLDER_SLUG)
-        db.add(folder)
-        db.flush()
-    elif not folder.slug:
-        folder.slug = LEGACY_FOLDER_SLUG
-    db.commit()
-    return zone
-
-
-def migrate_legacy_flat_years(db: Session) -> dict:
-    """Move top-level library_sources/YEAR/* into _unassigned/legacy/YEAR/."""
-    ensure_legacy_zone(db)
-    moved = 0
-    roots_touched = 0
-
-    for root in get_library_roots():
-        if not root.exists():
-            continue
-        root_changed = False
-        for entry in sorted(root.iterdir()):
-            if not entry.is_dir() or not _is_year_dir(entry.name):
-                continue
-            year = entry.name
-            dest_dir = root / LEGACY_ZONE_SLUG / LEGACY_FOLDER_SLUG / year
-            dest_dir.mkdir(parents=True, exist_ok=True)
-            for path in sorted(entry.iterdir()):
-                if not path.is_file():
-                    continue
-                if path.suffix.lower() not in ALLOWED_EXTENSIONS:
-                    continue
-                target = dest_dir / path.name
-                if target.exists():
-                    stem, suffix = path.stem, path.suffix
-                    n = 1
-                    while target.exists():
-                        target = dest_dir / f"{stem}_{n}{suffix}"
-                        n += 1
-                shutil.move(str(path), str(target))
-                old_rel = f"{year}/{path.name}"
-                new_rel = f"{LEGACY_ZONE_SLUG}/{LEGACY_FOLDER_SLUG}/{year}/{target.name}"
-                idx = db.query(DdaLocalFileIndex).filter(DdaLocalFileIndex.relative_path == old_rel).first()
-                if idx:
-                    idx.relative_path = new_rel
-                moved += 1
-                root_changed = True
-            try:
-                if entry.is_dir() and not any(entry.iterdir()):
-                    entry.rmdir()
-            except OSError:
-                pass
-        if root_changed:
-            roots_touched += 1
-
-    if moved:
-        db.commit()
-        logger.info("Legacy library migration: moved %d file(s) across %d root(s)", moved, roots_touched)
-    return {"moved": moved, "rootsTouched": roots_touched}
-
-
-def ensure_zone_folder_dirs(db: Session) -> None:
-    """Create on-disk folders for all zones/folders."""
-    root = get_writable_library_root()
-    root.mkdir(parents=True, exist_ok=True)
-    for zone in db.query(DdaZone).filter(DdaZone.slug.isnot(None)).all():
-        zone_dir = root / zone.slug
-        zone_dir.mkdir(parents=True, exist_ok=True)
-        for folder in db.query(DdaVillage).filter(DdaVillage.zone_id == zone.id).all():
-            if folder.slug:
-                (zone_dir / folder.slug).mkdir(parents=True, exist_ok=True)

app/dda/library_routes.py

@@ -86,8 +86,34 @@ def dda_config():
 @router.get("/hierarchy")
 def get_hierarchy(db: Session = Depends(get_db)):
     _require_dda()
-    from .local_library import scan_tree
-    return scan_tree(db)
+    zones = db.query(DdaZone).order_by(DdaZone.name).all()
+    tree = []
+    for zone in zones:
+        villages = (
+            db.query(DdaVillage)
+            .filter(DdaVillage.zone_id == zone.id)
+            .order_by(DdaVillage.name)
+            .all()
+        )
+        image_counts = {}
+        for v in villages:
+            cnt = db.query(ImageAsset).filter(ImageAsset.village_id == v.id).count()
+            if cnt:
+                image_counts[v.id] = cnt
+        tree.append({
+            "id": zone.id,
+            "name": zone.name,
+            "mode": zone.mode,
+            "villages": [
+                {
+                    "id": v.id,
+                    "name": v.name,
+                    "imageCount": image_counts.get(v.id, 0),
+                }
+                for v in villages
+            ],
+        })
+    return {"zones": tree}
 
 
 @router.get("/images")

app/dda/local_library.py

@@ -1,169 +1,67 @@
 """
-Read satellite/drone images from zone/folder/year hierarchy under library_sources/.
+Read satellite/drone images from local year-based folders.
 
-Canonical layout:
+Folder layout (under library_sources/):
 
     library_sources/
-      central_delhi/
-        site_a/
-          2024/
-            image_a.tif
-      _unassigned/
-        legacy/
-          2025/
-            old_image.tif
+      2024/
+        image_a.tif
+      2025/
+        image_c.tif
 
-Legacy flat library_sources/YEAR/ is still scanned (tagged legacy=true) until migrated.
+Copy files into library_sources/YEAR/ in the project folder (or data/library_sources/ on HF).
 """
 from __future__ import annotations
 
 import hashlib
 import logging
-from dataclasses import dataclass, field
+from dataclasses import dataclass
 from pathlib import Path
-from typing import Dict, List, Optional, Tuple
+from typing import List, Optional
 from urllib.parse import quote
 
 from fastapi import HTTPException
-from sqlalchemy.orm import Session
 
 from .config import ALLOWED_EXTENSIONS, LOCAL_THUMB_CACHE, get_library_roots
 from .geotiff_io import inspect_image, raster_to_preview_png, write_placeholder_png
-from .library_migration import LEGACY_FOLDER_SLUG, LEGACY_ZONE_SLUG
-from .models import DdaVillage, DdaZone
 
 logger = logging.getLogger(__name__)
 
 
-@dataclass
-class SlugLookup:
-    zone_by_slug: Dict[str, DdaZone] = field(default_factory=dict)
-    folder_by_zone_slug: Dict[str, Dict[str, DdaVillage]] = field(default_factory=dict)
-    zone_by_id: Dict[int, DdaZone] = field(default_factory=dict)
-    folder_by_id: Dict[int, DdaVillage] = field(default_factory=dict)
-
-
 @dataclass
 class LocalImageEntry:
-    path: str
+    path: str  # relative posix path, e.g. 2025/aerial.tif
     root: Path
     year: int
     filename: str
     file_size_bytes: int
-    zone_id: Optional[int] = None
-    zone_name: str = ""
-    folder_id: Optional[int] = None
-    folder_name: str = ""
-    legacy: bool = False
 
 
 def _is_year_dir(name: str) -> bool:
     return len(name) == 4 and name.isdigit() and 1990 <= int(name) <= 2100
 
 
-def build_slug_lookup(db: Session) -> SlugLookup:
-    lookup = SlugLookup()
-    for zone in db.query(DdaZone).filter(DdaZone.slug.isnot(None)).all():
-        lookup.zone_by_slug[zone.slug] = zone
-        lookup.zone_by_id[zone.id] = zone
-        lookup.folder_by_zone_slug[zone.slug] = {}
-    for folder in db.query(DdaVillage).filter(DdaVillage.slug.isnot(None)).all():
-        zone = lookup.zone_by_id.get(folder.zone_id)
-        if zone and zone.slug:
-            lookup.folder_by_zone_slug.setdefault(zone.slug, {})[folder.slug] = folder
-        lookup.folder_by_id[folder.id] = folder
-    return lookup
-
-
-def build_upload_dest(root: Path, zone_slug: str, folder_slug: str, year: int, filename: str) -> Path:
-    dest_dir = root / zone_slug / folder_slug / str(year)
-    dest_dir.mkdir(parents=True, exist_ok=True)
-    dest = dest_dir / filename
-    if dest.exists():
-        stem = Path(filename).stem
-        suffix = Path(filename).suffix
-        n = 1
-        while dest.exists():
-            dest = dest_dir / f"{stem}_{n}{suffix}"
-            n += 1
-    return dest
-
-
-def parse_library_path(rel_path: str, lookup: SlugLookup) -> Tuple[Optional[int], Optional[int], bool]:
-    """Return (zone_id, folder_id, legacy) from relative path."""
-    parts = rel_path.replace("\\", "/").split("/")
-    if len(parts) >= 4 and _is_year_dir(parts[2]):
-        zone_slug, folder_slug = parts[0], parts[1]
-        zone = lookup.zone_by_slug.get(zone_slug)
-        folder = lookup.folder_by_zone_slug.get(zone_slug, {}).get(folder_slug)
-        if zone and folder:
-            return zone.id, folder.id, zone_slug == LEGACY_ZONE_SLUG
-    if len(parts) == 2 and _is_year_dir(parts[0]):
-        return None, None, True
-    return None, None, False
-
-
-def _yield_files_in_year_dir(root: Path, year_dir: Path, rel_prefix: str, year: int,
-                             zone_id: Optional[int], zone_name: str,
-                             folder_id: Optional[int], folder_name: str, legacy: bool):
-    for path in sorted(year_dir.rglob("*")):
-        if not path.is_file():
-            continue
-        if path.suffix.lower() not in ALLOWED_EXTENSIONS:
-            continue
-        rel = f"{rel_prefix}/{path.relative_to(year_dir).as_posix()}".lstrip("/")
-        yield root, year, path, rel, zone_id, zone_name, folder_id, folder_name, legacy
-
-
-def _iter_all_images(root: Path, lookup: SlugLookup, year_filter: Optional[int] = None):
+def _iter_image_files(root: Path, year: Optional[int] = None):
     if not root.exists():
         return
-
-    for zone_dir in sorted(root.iterdir()):
-        if not zone_dir.is_dir():
-            continue
-
-        # Legacy flat: library_sources/2025/file.tif
-        if _is_year_dir(zone_dir.name):
-            y = int(zone_dir.name)
-            if year_filter is not None and y != year_filter:
+    if year is not None:
+        year_dirs = [root / str(year)] if (root / str(year)).is_dir() else []
+    else:
+        year_dirs = [d for d in sorted(root.iterdir()) if d.is_dir() and _is_year_dir(d.name)]
+    for ydir in year_dirs:
+        y = int(ydir.name)
+        for path in sorted(ydir.rglob("*")):
+            if not path.is_file():
                 continue
-            prefix = zone_dir.name
-            for item in _yield_files_in_year_dir(
-                root, zone_dir, prefix, y, None, "Unassigned", None, "Legacy", True
-            ):
-                yield item
-            continue
-
-        zone_slug = zone_dir.name
-        zone = lookup.zone_by_slug.get(zone_slug)
-        zone_name = zone.name if zone else zone_slug
-        zone_id = zone.id if zone else None
-        folders_map = lookup.folder_by_zone_slug.get(zone_slug, {})
-
-        for folder_dir in sorted(zone_dir.iterdir()):
-            if not folder_dir.is_dir():
+            ext = path.suffix.lower()
+            if ext not in ALLOWED_EXTENSIONS:
+                logger.debug("Skipped (extension %s): %s", ext, path)
                 continue
-            folder_slug = folder_dir.name
-            folder = folders_map.get(folder_slug)
-            folder_name = folder.name if folder else folder_slug
-            folder_id = folder.id if folder else None
-            is_legacy = zone_slug == LEGACY_ZONE_SLUG
-
-            for year_dir in sorted(folder_dir.iterdir()):
-                if not year_dir.is_dir() or not _is_year_dir(year_dir.name):
-                    continue
-                y = int(year_dir.name)
-                if year_filter is not None and y != year_filter:
-                    continue
-                prefix = f"{zone_slug}/{folder_slug}/{year_dir.name}"
-                for item in _yield_files_in_year_dir(
-                    root, year_dir, prefix, y, zone_id, zone_name, folder_id, folder_name, is_legacy
-                ):
-                    yield item
+            yield root, y, path
 
 
 def safe_resolve(relative_path: str) -> Path:
+    """Resolve a library-relative path across all configured roots."""
     rel = relative_path.replace("\\", "/").lstrip("/")
     if not rel or ".." in rel.split("/"):
         raise HTTPException(status_code=400, detail="Invalid image path")
@@ -178,35 +76,35 @@ def safe_resolve(relative_path: str) -> Path:
     raise HTTPException(status_code=404, detail="Image file not found")
 
 
-def scan_images(
-    db: Optional[Session] = None,
-    year: Optional[int] = None,
-    zone_id: Optional[int] = None,
-    folder_id: Optional[int] = None,
-    query: Optional[str] = None,
-    legacy_only: Optional[bool] = None,
-) -> List[LocalImageEntry]:
+def scan_years() -> List[dict]:
+    """List year folders and image counts (merged across all roots)."""
+    ensure_root()
+    counts: dict[int, int] = {}
+    for root in get_library_roots():
+        if not root.exists():
+            continue
+        for entry in sorted(root.iterdir()):
+            if not entry.is_dir() or not _is_year_dir(entry.name):
+                continue
+            y = int(entry.name)
+            n = sum(1 for _ in _iter_image_files(root, year=y))
+            counts[y] = counts.get(y, 0) + n
+    return [{"year": y, "imageCount": counts[y]} for y in sorted(counts)]
+
+
+def scan_images(year: Optional[int] = None, query: Optional[str] = None) -> List[LocalImageEntry]:
+    """Scan all library roots for images."""
     ensure_root()
-    lookup = build_slug_lookup(db) if db else SlugLookup()
     results: List[LocalImageEntry] = []
     seen_paths: set[str] = set()
     q = (query or "").strip().lower()
 
     for root in get_library_roots():
-        for (r, y, path, rel, zid, zname, fid, fname, legacy) in _iter_all_images(root, lookup, year_filter=year):
+        for r, y, path in _iter_image_files(root, year=year):
+            rel = path.relative_to(r).as_posix()
             if rel in seen_paths:
                 continue
-            if zone_id is not None and zid != zone_id:
-                continue
-            if folder_id is not None and fid != folder_id:
-                continue
-            if legacy_only is True:
-                parts = rel.split("/")
-                if not (len(parts) == 2 and _is_year_dir(parts[0])):
-                    continue
-            if legacy_only is False and legacy and len(rel.split("/")) == 2:
-                continue
-            if q and q not in rel.lower() and q not in path.name.lower():
+            if q and q not in rel.lower():
                 continue
             try:
                 size = path.stat().st_size
@@ -220,109 +118,13 @@ def scan_images(
                     year=y,
                     filename=path.name,
                     file_size_bytes=size,
-                    zone_id=zid,
-                    zone_name=zname,
-                    folder_id=fid,
-                    folder_name=fname,
-                    legacy=legacy,
                 )
             )
     return results
 
 
-def scan_years(db: Optional[Session] = None) -> List[dict]:
-    """Flat year list (backward compat for rescan endpoint)."""
-    counts: dict[int, int] = {}
-    for entry in scan_images(db=db):
-        counts[entry.year] = counts.get(entry.year, 0) + 1
-    return [{"year": y, "imageCount": counts[y]} for y in sorted(counts)]
-
-
-def scan_tree(db: Session) -> dict:
-    """Nested zone → folder → year tree with image counts from disk."""
-    lookup = build_slug_lookup(db)
-    zone_nodes: dict[int, dict] = {}
-    legacy_years: dict[int, int] = {}
-
-    for entry in scan_images(db=db):
-        if entry.legacy and not entry.zone_id:
-            legacy_years[entry.year] = legacy_years.get(entry.year, 0) + 1
-            continue
-        if entry.zone_id is None:
-            legacy_years[entry.year] = legacy_years.get(entry.year, 0) + 1
-            continue
-
-        zone = lookup.zone_by_id.get(entry.zone_id)
-        if not zone:
-            continue
-        znode = zone_nodes.setdefault(entry.zone_id, {
-            "id": zone.id,
-            "name": zone.name,
-            "slug": zone.slug,
-            "folders": {},
-        })
-        fid = entry.folder_id or 0
-        folder = lookup.folder_by_id.get(fid) if entry.folder_id else None
-        fnode = znode["folders"].setdefault(fid, {
-            "id": entry.folder_id,
-            "name": entry.folder_name or (folder.name if folder else "Unknown"),
-            "slug": folder.slug if folder else "",
-            "years": {},
-        })
-        fnode["years"][entry.year] = fnode["years"].get(entry.year, 0) + 1
-
-    # Include empty zones/folders from DB
-    for zone in db.query(DdaZone).order_by(DdaZone.name).all():
-        if not zone.slug:
-            continue
-        znode = zone_nodes.setdefault(zone.id, {
-            "id": zone.id,
-            "name": zone.name,
-            "slug": zone.slug,
-            "folders": {},
-        })
-        for folder in db.query(DdaVillage).filter(DdaVillage.zone_id == zone.id).order_by(DdaVillage.name).all():
-            if not folder.slug:
-                continue
-            znode["folders"].setdefault(folder.id, {
-                "id": folder.id,
-                "name": folder.name,
-                "slug": folder.slug,
-                "years": {},
-            })
-
-    zones_out = []
-    for znode in sorted(zone_nodes.values(), key=lambda z: z["name"].lower()):
-        folders_out = []
-        for fnode in sorted(znode["folders"].values(), key=lambda f: f["name"].lower()):
-            years_out = [
-                {"year": y, "imageCount": cnt}
-                for y, cnt in sorted(fnode["years"].items())
-            ]
-            folders_out.append({
-                "id": fnode["id"],
-                "name": fnode["name"],
-                "slug": fnode["slug"],
-                "years": years_out,
-            })
-        zones_out.append({
-            "id": znode["id"],
-            "name": znode["name"],
-            "slug": znode["slug"],
-            "folders": folders_out,
-        })
-
-    return {
-        "zones": zones_out,
-        "legacyYears": [{"year": y, "imageCount": c} for y, c in sorted(legacy_years.items())],
-    }
-
-
 def entry_to_dict(entry: LocalImageEntry, include_meta: bool = False) -> dict:
     encoded_path = quote(entry.path, safe="/")
-    breadcrumb = " / ".join(
-        p for p in (entry.zone_name, entry.folder_name, str(entry.year), entry.filename) if p
-    )
     out = {
         "path": entry.path,
         "year": entry.year,
@@ -331,12 +133,6 @@ def entry_to_dict(entry: LocalImageEntry, include_meta: bool = False) -> dict:
         "thumbUrl": f"/api/dda/local/thumb?path={encoded_path}",
         "source": "local_folder",
         "rootPath": str(entry.root),
-        "zoneId": entry.zone_id,
-        "zoneName": entry.zone_name,
-        "folderId": entry.folder_id,
-        "folderName": entry.folder_name,
-        "legacy": entry.legacy,
-        "breadcrumb": breadcrumb,
     }
     if include_meta:
         try:
@@ -379,42 +175,28 @@ def ensure_root() -> None:
     LOCAL_THUMB_CACHE.mkdir(parents=True, exist_ok=True)
 
 
-def count_files_in_folder(root: Path, zone_slug: str, folder_slug: str) -> int:
-    folder_path = root / zone_slug / folder_slug
-    if not folder_path.exists():
-        return 0
-    count = 0
-    for path in folder_path.rglob("*"):
-        if path.is_file() and path.suffix.lower() in ALLOWED_EXTENSIONS:
-            count += 1
-    return count
-
-
-def count_files_in_zone(root: Path, zone_slug: str) -> int:
-    zone_path = root / zone_slug
-    if not zone_path.exists():
-        return 0
-    count = 0
-    for path in zone_path.rglob("*"):
-        if path.is_file() and path.suffix.lower() in ALLOWED_EXTENSIONS:
-            count += 1
-    return count
-
-
-def library_debug_info(db: Optional[Session] = None) -> dict:
+def library_debug_info() -> dict:
+    """Diagnostics for troubleshooting missing images."""
     roots_info = []
     for root in get_library_roots():
-        info = {"path": str(root), "exists": root.exists(), "zones": [], "legacyYears": []}
+        info = {
+            "path": str(root),
+            "exists": root.exists(),
+            "years": [],
+            "otherFiles": [],
+        }
         if root.exists():
             for entry in sorted(root.iterdir()):
                 if entry.is_dir() and _is_year_dir(entry.name):
-                    files = [p.name for p in entry.iterdir() if p.is_file()]
-                    info["legacyYears"].append({"year": entry.name, "files": files})
-                elif entry.is_dir():
-                    info["zones"].append(entry.name)
+                    files = []
+                    for _, _, p in _iter_image_files(root, year=int(entry.name)):
+                        files.append({"name": p.name, "size": p.stat().st_size})
+                    info["years"].append({"year": entry.name, "files": files})
+                elif entry.is_file() and entry.name not in ("README.md", ".gitkeep"):
+                    info["otherFiles"].append(entry.name)
         roots_info.append(info)
     return {
         "roots": roots_info,
         "allowedExtensions": sorted(ALLOWED_EXTENSIONS),
-        "totalImages": len(scan_images(db=db)),
+        "totalImages": len(scan_images()),
     }

app/dda/local_routes.py

@@ -1,13 +1,11 @@
-"""API for reading images from local library_sources/ zone/folder/year hierarchy."""
+"""API for reading images from local library_sources/ year folders."""
 import logging
-import shutil
 from pathlib import Path
 from typing import Optional
 
 from fastapi import APIRouter, Depends, File, Form, HTTPException, Query, Request, UploadFile
 from fastapi.responses import FileResponse
 from PIL import Image
-from pydantic import BaseModel, Field
 from sqlalchemy.orm import Session
 
 from ..database import get_db
@@ -27,16 +25,13 @@ from .config import (
     max_upload_bytes_for_extension,
 )
 from .local_library import (
-    build_upload_dest,
     entry_to_dict,
     get_or_build_thumb,
     library_debug_info,
     safe_resolve,
     scan_images,
-    scan_tree,
     scan_years,
 )
-from .models import DdaLocalFileIndex, DdaVillage, DdaZone
 from .upload_io import stream_upload_to_file
 
 logger = logging.getLogger(__name__)
@@ -58,31 +53,6 @@ def _safe_basename(filename: str) -> str:
     return name
 
 
-def _upsert_file_index(db: Session, rel_path: str, zone_id: int, folder_id: int, year: int, user_id: int):
-    idx = db.query(DdaLocalFileIndex).filter(DdaLocalFileIndex.relative_path == rel_path).first()
-    if idx:
-        idx.zone_id = zone_id
-        idx.folder_id = folder_id
-        idx.year = year
-        idx.uploaded_by = user_id
-    else:
-        db.add(DdaLocalFileIndex(
-            relative_path=rel_path,
-            zone_id=zone_id,
-            folder_id=folder_id,
-            year=year,
-            uploaded_by=user_id,
-        ))
-    db.commit()
-
-
-class ReassignBody(BaseModel):
-    path: str
-    zone_id: int
-    folder_id: int
-    year: int = Field(..., ge=1990, le=2100)
-
-
 @router.get("/local/config")
 def local_library_config():
     _require_dda()
@@ -91,13 +61,13 @@ def local_library_config():
     hosted = is_hf_hosted()
     if hosted:
         instructions = (
-            "Upload images below with zone, folder, and year. Files are saved under "
-            "library_sources/{zone}/{folder}/{year}/ on persistent Space storage."
+            "On Hugging Face, images must be uploaded below (saved to persistent storage) "
+            "or copied into the writable folder shown. Files on your PC are not visible here."
         )
     else:
         instructions = (
-            "Copy .tif images into library_sources/{zone}/{folder}/{year}/, or use Upload "
-            "with zone and folder selected. Click Refresh after adding files manually."
+            "Copy .tif images into library_sources/YEAR/ in your project folder, then Refresh. "
+            "Or use Upload to save into data/library_sources/."
         )
     return {
         "source": "local_folder",
@@ -117,49 +87,36 @@ def local_library_config():
 
 
 @router.get("/local/debug")
-def local_debug(db: Session = Depends(get_db)):
+def local_debug():
     _require_dda()
-    return library_debug_info(db=db)
+    return library_debug_info()
 
 
 @router.get("/local/years")
-def local_years(db: Session = Depends(get_db)):
-    _require_dda()
-    return {"years": scan_years(db=db), "rootPaths": [str(r) for r in get_library_roots()]}
-
-
-@router.get("/local/tree")
-def local_tree(db: Session = Depends(get_db)):
+def local_years():
     _require_dda()
-    return scan_tree(db)
+    return {"years": scan_years(), "rootPaths": [str(r) for r in get_library_roots()]}
 
 
 @router.get("/local/images")
 def local_images(
     year: Optional[int] = Query(None),
-    zone_id: Optional[int] = Query(None),
-    folder_id: Optional[int] = Query(None),
-    legacy_only: Optional[bool] = Query(None),
     q: Optional[str] = Query(None),
-    db: Session = Depends(get_db),
 ):
     _require_dda()
-    entries = scan_images(
-        db=db, year=year, zone_id=zone_id, folder_id=folder_id,
-        query=q, legacy_only=legacy_only,
-    )
+    entries = scan_images(year=year, query=q)
     return [entry_to_dict(e) for e in entries]
 
 
 @router.get("/local/images/detail")
-def local_image_detail(path: str = Query(..., description="Relative path e.g. zone/folder/2025/aerial.tif"), db: Session = Depends(get_db)):
+def local_image_detail(path: str = Query(..., description="Relative path e.g. 2025/aerial.tif")):
     _require_dda()
-    entries = scan_images(db=db)
+    entries = scan_images()
     norm = path.replace("\\", "/")
     match = next((e for e in entries if e.path == norm), None)
     if not match:
         safe_resolve(path)
-        match = next((e for e in scan_images(db=db) if e.path == norm), None)
+        match = next((e for e in scan_images() if e.path == norm), None)
     if not match:
         raise HTTPException(status_code=404, detail="Image not found in library scan")
     return entry_to_dict(match, include_meta=True)
@@ -187,25 +144,16 @@ def local_thumb(path: str = Query(...)):
 async def local_upload(
     request: Request,
     file: UploadFile = File(...),
-    zone_id: int = Form(...),
-    folder_id: int = Form(...),
     year: int = Form(...),
     db: Session = Depends(get_db),
     user: User = Depends(current_dda_user),
 ):
-    """Upload GeoTIFF into library_sources/{zone}/{folder}/{year}/."""
+    """Upload GeoTIFF into persistent library_sources/YEAR/ (required on HF)."""
     _require_dda()
     require_min_role(user, db, "uploader")
     if year < 1990 or year > 2100:
         raise HTTPException(status_code=400, detail="year must be between 1990 and 2100")
 
-    zone = db.query(DdaZone).filter(DdaZone.id == zone_id).first()
-    folder = db.query(DdaVillage).filter(
-        DdaVillage.id == folder_id, DdaVillage.zone_id == zone_id
-    ).first()
-    if not zone or not folder or not zone.slug or not folder.slug:
-        raise HTTPException(status_code=400, detail="Invalid zone or folder")
-
     original = _safe_basename(file.filename or "upload")
     ext = Path(original).suffix.lower()
     from .config import ALLOWED_EXTENSIONS
@@ -213,79 +161,40 @@ async def local_upload(
         raise HTTPException(status_code=400, detail=f"Allowed: {', '.join(sorted(ALLOWED_EXTENSIONS))}")
 
     root = get_writable_library_root()
-    dest = build_upload_dest(root, zone.slug, folder.slug, year, original)
+    dest = root / str(year) / original
+    if dest.exists():
+        stem = Path(original).stem
+        suffix = Path(original).suffix
+        n = 1
+        while dest.exists():
+            dest = root / str(year) / f"{stem}_{n}{suffix}"
+            n += 1
+
     size = await stream_upload_to_file(file, dest, max_upload_bytes_for_extension(ext))
     rel = dest.relative_to(root).as_posix()
     logger.info("Library upload: %s (%d bytes) -> %s", original, size, dest)
 
-    _upsert_file_index(db, rel, zone.id, folder.id, year, user.id)
-
-    entries = scan_images(db=db, year=year, zone_id=zone_id, folder_id=folder_id)
+    entries = scan_images(year=year)
     match = next((e for e in entries if e.path == rel or e.filename == dest.name), None)
     if match:
         return {"status": "success", "path": match.path, "image": entry_to_dict(match)}
     return {
         "status": "success",
-        "path": rel,
+        "path": f"{year}/{dest.name}",
         "fileSizeBytes": size,
         "writablePath": str(dest),
     }
 
 
-@router.post("/local/reassign")
-def local_reassign(
-    body: ReassignBody,
-    db: Session = Depends(get_db),
-    user: User = Depends(current_dda_user),
-):
-    """Move a library file to zone/folder/year and update index."""
-    _require_dda()
-    require_min_role(user, db, "uploader")
-
-    zone = db.query(DdaZone).filter(DdaZone.id == body.zone_id).first()
-    folder = db.query(DdaVillage).filter(
-        DdaVillage.id == body.folder_id, DdaVillage.zone_id == body.zone_id
-    ).first()
-    if not zone or not folder or not zone.slug or not folder.slug:
-        raise HTTPException(status_code=400, detail="Invalid zone or folder")
-
-    src_rel = body.path.replace("\\", "/").strip()
-    src = safe_resolve(src_rel)
-    root = get_writable_library_root()
-    try:
-        src.relative_to(root.resolve())
-    except ValueError:
-        raise HTTPException(status_code=400, detail="Only files in writable library can be reassigned")
-
-    dest = build_upload_dest(root, zone.slug, folder.slug, body.year, src.name)
-    if dest.resolve() != src.resolve():
-        shutil.move(str(src), str(dest))
-    new_rel = dest.relative_to(root).as_posix()
-
-    old_idx = db.query(DdaLocalFileIndex).filter(DdaLocalFileIndex.relative_path == src_rel).first()
-    if old_idx:
-        db.delete(old_idx)
-        db.commit()
-    _upsert_file_index(db, new_rel, zone.id, folder.id, body.year, user.id)
-
-    entries = scan_images(db=db)
-    match = next((e for e in entries if e.path == new_rel), None)
-    if not match:
-        raise HTTPException(status_code=500, detail="File moved but not found in scan")
-    return {"status": "success", "path": new_rel, "image": entry_to_dict(match)}
-
-
 @router.post("/local/rescan")
-def local_rescan(db: Session = Depends(get_db)):
+def local_rescan():
     _require_dda()
-    tree = scan_tree(db)
-    total = len(scan_images(db=db))
-    years = scan_years(db=db)
-    info = library_debug_info(db=db)
+    years = scan_years()
+    total = sum(y["imageCount"] for y in years)
+    info = library_debug_info()
     logger.info("Library rescan: %d images, roots=%s", total, info.get("roots"))
     return {
         "ok": True,
-        "tree": tree,
         "years": years,
         "totalImages": total,
         "rootPaths": [str(r) for r in get_library_roots()],
@@ -311,7 +220,7 @@ async def detect_from_library(
     db: Session = Depends(get_db),
     user: User = Depends(current_dda_user),
 ):
-    """Run change detection on two library images by relative path."""
+    """Run change detection on two library images by relative path (e.g. 2025/aerial.tif)."""
     _require_dda()
     base_norm = base_path.replace("\\", "/").strip()
     comp_norm = comparison_path.replace("\\", "/").strip()
@@ -336,6 +245,7 @@ async def detect_from_library(
     except Exception as exc:
         raise HTTPException(status_code=400, detail=f"Could not load images: {exc}") from exc
 
+    # Match dimensions so registration and overlay align with the before image
     if before_pil.size != after_pil.size:
         after_pil = after_pil.resize(before_pil.size, Image.Resampling.LANCZOS)
 

app/dda/models.py

@@ -16,7 +16,6 @@ class DdaZone(Base):
 
     id = Column(Integer, primary_key=True, index=True)
     name = Column(String(128), unique=True, nullable=False, index=True)
-    slug = Column(String(64), unique=True, nullable=True, index=True)
     mode = Column(String(32), default="admin")  # admin | grid_parent
     created_at = Column(DateTime, default=_utcnow)
 
@@ -24,35 +23,17 @@ class DdaZone(Base):
 
 
 class DdaVillage(Base):
-    """Folder under a zone (exposed as folder in API/UI)."""
     __tablename__ = "dda_villages"
 
     id = Column(Integer, primary_key=True, index=True)
     zone_id = Column(Integer, ForeignKey("dda_zones.id"), nullable=False, index=True)
     name = Column(String(128), nullable=False, index=True)
-    slug = Column(String(64), nullable=True, index=True)
     created_at = Column(DateTime, default=_utcnow)
 
     zone = relationship("DdaZone", back_populates="villages")
     images = relationship("ImageAsset", back_populates="village")
 
 
-class DdaLocalFileIndex(Base):
-    """Maps library-relative paths to zone/folder/year for traceability."""
-    __tablename__ = "dda_local_file_index"
-
-    id = Column(Integer, primary_key=True, index=True)
-    relative_path = Column(String(512), unique=True, nullable=False, index=True)
-    zone_id = Column(Integer, ForeignKey("dda_zones.id"), nullable=True, index=True)
-    folder_id = Column(Integer, ForeignKey("dda_villages.id"), nullable=True, index=True)
-    year = Column(Integer, nullable=True, index=True)
-    uploaded_by = Column(Integer, ForeignKey("users.id"), nullable=True)
-    created_at = Column(DateTime, default=_utcnow)
-
-    zone = relationship("DdaZone")
-    folder = relationship("DdaVillage")
-
-
 class ImageAsset(Base):
     """Centralized satellite / drone image (FR-01, FR-02)."""
     __tablename__ = "dda_image_assets"

app/dda/path_slugs.py

@@ -1,48 +0,0 @@
-"""Filesystem-safe slugs for zone/folder library paths."""
-from __future__ import annotations
-
-import re
-import unicodedata
-from typing import Iterable, Optional, Set
-
-RESERVED_SLUGS = frozenset({"_unassigned", "legacy", "thumbs", "cache"})
-
-
-def slugify(name: str, *, fallback: str = "item") -> str:
-    """Convert display name to a safe path segment."""
-    text = unicodedata.normalize("NFKD", (name or "").strip())
-    text = text.encode("ascii", "ignore").decode("ascii")
-    text = re.sub(r"[^\w\s-]", "", text, flags=re.UNICODE)
-    text = re.sub(r"[\s_-]+", "_", text).strip("_").lower()
-    if not text:
-        text = fallback
-    if text in RESERVED_SLUGS:
-        text = f"{text}_1"
-    return text[:64]
-
-
-def unique_slug(base: str, existing: Set[str]) -> str:
-    """Return base or base-2, base-3, … if base is taken."""
-    slug = slugify(base)
-    if slug not in existing:
-        return slug
-    n = 2
-    while True:
-        candidate = f"{slug}-{n}"[:64]
-        if candidate not in existing:
-            return candidate
-        n += 1
-
-
-def validate_path_segment(segment: str) -> bool:
-    if not segment or segment in (".", ".."):
-        return False
-    if ".." in segment.split("/"):
-        return False
-    if not re.match(r"^[a-z0-9][a-z0-9_-]*$", segment, re.IGNORECASE):
-        return False
-    return True
-
-
-def zone_folder_path(zone_slug: str, folder_slug: str, year: int) -> str:
-    return f"{zone_slug}/{folder_slug}/{year}"

app/dda/seed.py

@@ -3,7 +3,6 @@ import logging
 from sqlalchemy.orm import Session
 
 from .models import DdaVillage, DdaZone
-from .path_slugs import unique_slug
 from .seed_data import DELHI_ZONES
 
 logger = logging.getLogger(__name__)
@@ -13,25 +12,17 @@ def seed_delhi_hierarchy(db: Session) -> dict:
     """Insert Zone → Village hierarchy if empty. Idempotent."""
     existing = db.query(DdaZone).count()
     if existing > 0:
-        from .library_migration import backfill_slugs
-        backfill_slugs(db)
         return {"seeded": False, "zones": existing}
 
     zones_created = 0
     villages_created = 0
-    zone_slugs: set = set()
     for zone_name, villages in DELHI_ZONES.items():
-        slug = unique_slug(zone_name, zone_slugs)
-        zone_slugs.add(slug)
-        zone = DdaZone(name=zone_name, slug=slug, mode="admin")
+        zone = DdaZone(name=zone_name, mode="admin")
         db.add(zone)
         db.flush()
         zones_created += 1
-        folder_slugs: set = set()
         for village_name in villages:
-            fslug = unique_slug(village_name, folder_slugs)
-            folder_slugs.add(fslug)
-            db.add(DdaVillage(zone_id=zone.id, name=village_name, slug=fslug))
+            db.add(DdaVillage(zone_id=zone.id, name=village_name))
             villages_created += 1
 
     db.commit()

app/main.py

@@ -28,7 +28,7 @@ from .auth import (
 from .database import Base, engine, get_db, DATA_DIR
 from .models import User, DetectionRun
 from . import dda as _dda_pkg  # noqa: F401 — register DDA tables
-from .dda.models import DdaZone, DdaVillage, ImageAsset, DetectionJob, RegionReview, DdaLocalFileIndex  # noqa: F401
+from .dda.models import DdaZone, DdaVillage, ImageAsset, DetectionJob, RegionReview  # noqa: F401
 from .dda.config import IS_DDA_MODE
 from .dda.bootstrap import init_dda_database, setup_dda
 from .notifier import send_notification, send_test_email

static/css/dda.css

@@ -83,43 +83,6 @@
   background: var(--bg-hover);
   color: var(--grad-start);
 }
-.dda-sidebar-actions { display: flex; gap: 0.35rem; flex-wrap: wrap; }
-.dda-tree-all {
-  display: block;
-  width: 100%;
-  text-align: left;
-  padding: 0.4rem 0.55rem;
-  margin-bottom: 0.35rem;
-  border: none;
-  background: transparent;
-  color: var(--text);
-  cursor: pointer;
-  border-radius: 6px;
-  font-weight: 600;
-}
-.dda-tree-all:hover, .dda-tree-all.active {
-  background: var(--bg-hover);
-  color: var(--grad-start);
-}
-.dda-tree-zone { margin-bottom: 0.25rem; }
-.dda-tree-zone-summary, .dda-tree-folder-summary {
-  cursor: pointer;
-  font-weight: 600;
-  padding: 0.25rem 0;
-  color: var(--text);
-}
-.dda-tree-folders { padding-left: 0.5rem; }
-.dda-tree-folder { margin: 0.15rem 0; }
-.dda-tree-years { padding-left: 0.75rem; margin-bottom: 0.25rem; }
-.dda-tree-empty { font-size: 0.8rem; display: block; padding: 0.2rem 0; }
-.dda-tree-legacy .dda-tree-zone-summary { color: var(--text-muted); }
-.dda-crumb { font-size: 0.78rem; line-height: 1.3; }
-.dda-assign-btn { margin-top: 0.35rem; }
-.dda-manage-panel { max-width: 520px; width: 100%; }
-.dda-manage-section { margin-bottom: 1rem; }
-.dda-manage-section h4 { margin: 0 0 0.5rem; font-size: 0.9rem; }
-.dda-manage-section .location-row { margin-bottom: 0.5rem; flex-wrap: wrap; gap: 0.4rem; }
-.dda-manage-section input, .dda-manage-section select { flex: 1 1 auto; min-width: 120px; }
 
 .dda-folder-path {
   font-size: 0.78rem;

static/js/dda/app.js

@@ -55,32 +55,15 @@ function formatBytes(n) {
 }
 
 let ddaConfig = null;
-let libraryTree = null;
-const selection = { zoneId: null, zoneName: '', folderId: null, folderName: '', year: null, legacy: false };
+let localYears = [];
+let selectedYear = null;
 
 window.ddaState = {
   get config() { return ddaConfig; },
   get localCfg() { return window._localCfg; },
-  get tree() { return libraryTree; },
-  get selection() { return { ...selection }; },
-  get userRole() { return window._ddaUserRole || 'analyst'; },
-  set userRole(r) { window._ddaUserRole = r; },
-  setSelection(s) {
-    selection.zoneId = s.zoneId ?? null;
-    selection.zoneName = s.zoneName || '';
-    selection.folderId = s.folderId ?? null;
-    selection.folderName = s.folderName || '';
-    selection.year = s.year ?? null;
-    selection.legacy = !!s.legacy;
-  },
-  clearSelection() {
-    selection.zoneId = null;
-    selection.zoneName = '';
-    selection.folderId = null;
-    selection.folderName = '';
-    selection.year = null;
-    selection.legacy = false;
-  },
+  get years() { return localYears; },
+  get selectedYear() { return selectedYear; },
+  setYear(year) { selectedYear = year; },
   refreshImages: () => loadLibraryImages(),
   rescan: () => rescanLibrary(),
 };
@@ -100,8 +83,8 @@ document.querySelectorAll('.dda-tab').forEach((btn) => {
 
 async function rescanLibrary() {
   const data = await ddaApi('POST', '/api/dda/local/rescan');
-  libraryTree = data.tree || null;
-  if (typeof renderLibraryTree === 'function' && libraryTree) renderLibraryTree(libraryTree);
+  localYears = data.years || [];
+  if (typeof renderYearTree === 'function') renderYearTree(localYears);
   await loadLibraryImages();
   return data;
 }
@@ -113,13 +96,6 @@ async function initDda() {
     const localCfg = await ddaApi('GET', '/api/dda/local/config');
     window._localCfg = localCfg;
 
-    try {
-      const me = await ddaApi('GET', '/api/dda/me');
-      window.ddaState.userRole = me.role || 'analyst';
-    } catch (_) {
-      window.ddaState.userRole = 'analyst';
-    }
-
     const hint = document.getElementById('lib-config-hint');
     if (hint) {
       hint.textContent = localCfg.geotiffEnabled ? 'GeoTIFF ready' : 'GeoTIFF limited';
@@ -130,7 +106,6 @@ async function initDda() {
       pathEl.textContent = [
         localCfg.isHosted ? 'HF writable storage:' : 'Local folders:',
         localCfg.writablePath || paths[0] || '',
-        'Layout: {zone}/{folder}/{year}/image.tif',
         ...paths.filter((p) => p !== localCfg.writablePath),
       ].filter(Boolean).join('\n');
     }
@@ -143,17 +118,8 @@ async function initDda() {
     const instr = document.getElementById('lib-instructions');
     if (instr && localCfg.instructions) instr.textContent = localCfg.instructions;
 
-    const uploadTitle = document.getElementById('upload-card-title');
-    const uploadHint = document.getElementById('upload-card-hint');
-    if (uploadTitle) {
-      uploadTitle.textContent = localCfg.isHosted ? 'Upload to Space storage' : 'Upload to library';
-    }
-    if (uploadHint) {
-      uploadHint.textContent = localCfg.isHosted ? 'Required on Hugging Face' : 'Optional — or copy files manually';
-    }
-
-    const manageBtn = document.getElementById('btn-manage-library');
-    if (manageBtn) manageBtn.classList.toggle('hidden', window.ddaState.userRole !== 'admin');
+    const hfUpload = document.getElementById('hf-upload-card');
+    if (hfUpload) hfUpload.classList.toggle('hidden', !localCfg.isHosted);
 
     const resHint = document.getElementById('dda-detect-res-hint');
     if (resHint && localCfg.detectionMaxSide) {
@@ -162,7 +128,7 @@ async function initDda() {
 
     const uploadLimit = document.getElementById('hf-upload-limit');
     if (uploadLimit && localCfg.maxUploadGb) {
-      uploadLimit.textContent = `Select zone, folder, and year. Upload .tif images (up to ${localCfg.maxUploadGb} GB each).`;
+      uploadLimit.textContent = `Files on your computer are not on the server. Upload .tif images here (up to ${localCfg.maxUploadGb} GB each).`;
     }
 
     const appMode = ddaConfig.appMode || ddaConfig.mode || localCfg.appMode || 'dda';
@@ -175,61 +141,76 @@ async function initDda() {
       document.querySelector(`.dda-tab[data-tab="${urlTab}"]`)?.click();
     }
 
-    libraryTree = await (typeof loadLibraryTree === 'function' ? loadLibraryTree() : null);
-    if (typeof populateUploadZones === 'function') await populateUploadZones();
+    const yearsData = await ddaApi('GET', '/api/dda/local/years');
+    localYears = yearsData.years || [];
+    if (typeof renderYearTree === 'function') renderYearTree(localYears);
     await loadLibraryImages();
+    await loadHierarchyTree();
   } catch (err) {
     showDdaError(err.message || 'Failed to load library');
   }
 }
 
-function selectionTitle() {
-  const s = window.ddaState.selection;
-  if (s.legacy && s.year) return `Unassigned — ${s.year}`;
-  const parts = [];
-  if (s.zoneName) parts.push(s.zoneName);
-  if (s.folderName) parts.push(s.folderName);
-  if (s.year) parts.push(String(s.year));
-  return parts.length ? parts.join(' / ') : 'All images';
+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 = `<p class="dim" style="margin-bottom:0.5rem">DB hierarchy (upload API). Local library uses year folders.</p>` +
+      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');
   if (!grid) return;
   const q = document.getElementById('lib-filter')?.value?.trim() || '';
-  const s = window.ddaState.selection;
   const params = new URLSearchParams();
-  if (s.legacy && s.year) {
-    params.set('year', String(s.year));
-    params.set('legacy_only', 'true');
-  } else {
-    if (s.zoneId) params.set('zone_id', String(s.zoneId));
-    if (s.folderId) params.set('folder_id', String(s.folderId));
-    if (s.year) params.set('year', String(s.year));
-  }
+  if (selectedYear) params.set('year', String(selectedYear));
   if (q) params.set('q', q);
-  if (title) title.textContent = `Images — ${selectionTitle()}`;
+  if (title) {
+    title.textContent = selectedYear ? `Images — ${selectedYear}` : 'Images — all years';
+  }
   try {
     const items = await ddaApi('GET', '/api/dda/local/images?' + params.toString());
     window.ddaState.libraryItems = items;
     if (!items.length) {
-      grid.innerHTML = `<p class="dim">No images in ${escapeHtml(selectionTitle())}. Upload or copy files into <code>library_sources/zone/folder/year/</code>, then Refresh.</p>`;
+      const hf = window.ddaState?.localCfg?.isHosted;
+      grid.innerHTML = hf
+        ? `<p class="dim">No images on this Space yet. Use <strong>Upload to Space storage</strong> above (2025 / 2026), then click Refresh.</p>`
+        : `<p class="dim">No images in ${selectedYear || 'library_sources'}. Copy .tif files into <code>library_sources/${selectedYear || 'YEAR'}/</code> and click Refresh.</p>`;
       return;
     }
     grid.innerHTML = items.map((img) => {
       const thumb = img.thumbUrl ? img.thumbUrl.replace(/path=[^&]+/, 'path=' + encodeURIComponent(img.path)) : '';
-      const crumb = img.breadcrumb || `${img.year} / ${img.filename}`;
-      const assignBtn = img.legacy
-        ? `<button type="button" class="btn btn-secondary btn-sm dda-assign-btn" data-path="${img.path.replace(/"/g, '&quot;')}" data-filename="${escapeHtml(img.filename)}">Assign location</button>`
-        : '';
       return `
       <div class="dda-card-img" draggable="true" data-image-path="${img.path.replace(/"/g, '&quot;')}" title="${escapeHtml(img.filename)}">
         ${thumb ? `<img src="${thumb}" alt="" loading="lazy" />` : '<div class="meta">No preview</div>'}
         <div class="meta">
-          <span class="dim dda-crumb">${escapeHtml(crumb)}</span><br/>
+          <strong>${escapeHtml(String(img.year))}</strong><br/>
+          ${escapeHtml(img.filename)}<br/>
           <span class="dim">${formatBytes(img.fileSizeBytes)}</span>
-          ${assignBtn}
         </div>
       </div>`;
     }).join('');
@@ -239,14 +220,6 @@ async function loadLibraryImages() {
         e.dataTransfer.setData('text/plain', card.dataset.imagePath);
       });
     });
-    grid.querySelectorAll('.dda-assign-btn').forEach((btn) => {
-      btn.addEventListener('click', (e) => {
-        e.stopPropagation();
-        if (typeof openReassignModal === 'function') {
-          openReassignModal(btn.dataset.path, btn.dataset.filename);
-        }
-      });
-    });
     if (typeof loadCompareLibraryGrid === 'function') loadCompareLibraryGrid();
   } catch (err) {
     grid.innerHTML = `<p class="dim">Could not load images: ${err.message}</p>`;

static/js/dda/hierarchy.js

@@ -1,359 +0,0 @@
-/** Zone → folder → year library tree and admin management. */
-
-let libraryTreeData = null;
-
-function isAdminRole() {
-  const role = window.ddaState?.userRole || '';
-  return role === 'admin';
-}
-
-function canUploadRole() {
-  const rank = { viewer: 0, uploader: 1, analyst: 2, admin: 3 };
-  const role = window.ddaState?.userRole || 'analyst';
-  return (rank[role] || 0) >= rank.uploader;
-}
-
-function selectionLabel() {
-  const s = window.ddaState?.selection || {};
-  const parts = [];
-  if (s.zoneName) parts.push(s.zoneName);
-  if (s.folderName) parts.push(s.folderName);
-  if (s.year) parts.push(String(s.year));
-  return parts.length ? parts.join(' / ') : 'All images';
-}
-
-function renderLibraryTree(tree) {
-  const el = document.getElementById('lib-tree');
-  if (!el) return;
-  libraryTreeData = tree;
-  const filter = (document.getElementById('lib-tree-search')?.value || '').toLowerCase();
-  const sel = window.ddaState?.selection || {};
-
-  const allActive = !sel.zoneId && !sel.legacy && !sel.year;
-  const allBtn = `
-    <button type="button" class="dda-tree-node dda-tree-all ${allActive ? 'active' : ''}">
-      All images
-    </button>`;
-
-  let html = allBtn;
-
-  const zones = (tree?.zones || []).filter((z) => {
-    if (!filter) return true;
-    const zMatch = z.name.toLowerCase().includes(filter);
-    const fMatch = (z.folders || []).some((f) =>
-      f.name.toLowerCase().includes(filter) ||
-      (f.years || []).some((y) => String(y.year).includes(filter))
-    );
-    return zMatch || fMatch;
-  });
-
-  zones.forEach((zone) => {
-    const zoneOpen = sel.zoneId === zone.id || !filter;
-    html += `<details class="dda-tree-zone" ${zoneOpen ? 'open' : ''} data-zone-id="${zone.id}">`;
-    html += `<summary class="dda-tree-zone-summary">${escapeHtml(zone.name)}</summary>`;
-    html += '<div class="dda-tree-folders">';
-
-    (zone.folders || []).forEach((folder) => {
-      if (filter && !zone.name.toLowerCase().includes(filter) &&
-          !folder.name.toLowerCase().includes(filter) &&
-          !(folder.years || []).some((y) => String(y.year).includes(filter))) {
-        return;
-      }
-      const folderOpen = sel.folderId === folder.id || filter;
-      html += `<details class="dda-tree-folder" ${folderOpen ? 'open' : ''} data-folder-id="${folder.id}">`;
-      html += `<summary class="dda-tree-folder-summary">${escapeHtml(folder.name)}</summary>`;
-      html += '<div class="dda-tree-years">';
-
-      const years = folder.years || [];
-      if (!years.length) {
-        html += '<span class="dim dda-tree-empty">No year folders yet</span>';
-      }
-      years.forEach((y) => {
-        if (filter && !String(y.year).includes(filter) &&
-            !folder.name.toLowerCase().includes(filter) &&
-            !zone.name.toLowerCase().includes(filter)) return;
-        const active = sel.zoneId === zone.id && sel.folderId === folder.id && sel.year === y.year;
-        html += `<button type="button" class="dda-tree-year ${active ? 'active' : ''}"
-          data-zone-id="${zone.id}" data-folder-id="${folder.id}" data-year="${y.year}">
-          ${y.year} <span class="dim">(${y.imageCount})</span>
-        </button>`;
-      });
-      html += '</div></details>';
-    });
-
-    html += '</div></details>';
-  });
-
-  const legacy = tree?.legacyYears || [];
-  if (legacy.length) {
-    html += '<details class="dda-tree-zone dda-tree-legacy" open>';
-    html += '<summary class="dda-tree-zone-summary">Unassigned (legacy)</summary><div class="dda-tree-years">';
-    legacy.forEach((y) => {
-      const active = sel.legacy && sel.year === y.year;
-      html += `<button type="button" class="dda-tree-year dda-tree-legacy-year ${active ? 'active' : ''}"
-        data-legacy="1" data-year="${y.year}">
-        ${y.year} <span class="dim">(${y.imageCount})</span>
-      </button>`;
-    });
-    html += '</div></details>';
-  }
-
-  if (!zones.length && !legacy.length) {
-    html += '<p class="dim">No zones yet. Admins can add zones under Manage library.</p>';
-  }
-
-  el.innerHTML = html;
-
-  el.querySelector('.dda-tree-all')?.addEventListener('click', () => {
-    window.ddaState.clearSelection();
-    window.ddaState.refreshImages();
-    renderLibraryTree(libraryTreeData);
-  });
-
-  el.querySelectorAll('.dda-tree-year').forEach((btn) => {
-    btn.addEventListener('click', () => {
-      if (btn.dataset.legacy) {
-        window.ddaState.setSelection({ legacy: true, year: parseInt(btn.dataset.year, 10) });
-      } else {
-        const zoneId = parseInt(btn.dataset.zoneId, 10);
-        const folderId = parseInt(btn.dataset.folderId, 10);
-        const year = parseInt(btn.dataset.year, 10);
-        let zoneName = '';
-        let folderName = '';
-        for (const z of (libraryTreeData?.zones || [])) {
-          if (z.id === zoneId) {
-            zoneName = z.name;
-            const f = (z.folders || []).find((x) => x.id === folderId);
-            if (f) folderName = f.name;
-            break;
-          }
-        }
-        window.ddaState.setSelection({
-          zoneId, zoneName, folderId, folderName, year, legacy: false,
-        });
-      }
-      if (typeof syncUploadPickers === 'function') syncUploadPickers();
-      window.ddaState.refreshImages();
-      renderLibraryTree(libraryTreeData);
-    });
-  });
-}
-
-document.getElementById('lib-tree-search')?.addEventListener('input', () => {
-  if (libraryTreeData) renderLibraryTree(libraryTreeData);
-});
-
-async function loadLibraryTree() {
-  try {
-    const tree = await ddaApi('GET', '/api/dda/hierarchy/tree');
-    renderLibraryTree(tree);
-    return tree;
-  } catch (_) {
-    const el = document.getElementById('lib-tree');
-    if (el) el.innerHTML = '<p class="dim">Could not load library tree.</p>';
-    return null;
-  }
-}
-
-window.loadLibraryTree = loadLibraryTree;
-window.renderLibraryTree = renderLibraryTree;
-
-/* ---- Manage library modal ---- */
-
-function openManageModal() {
-  document.getElementById('dda-manage-modal')?.classList.remove('hidden');
-  populateManageZones();
-}
-
-function closeManageModal() {
-  document.getElementById('dda-manage-modal')?.classList.add('hidden');
-}
-
-async function populateManageZones() {
-  const sel = document.getElementById('manage-zone-select');
-  if (!sel) return;
-  try {
-    const tree = await ddaApi('GET', '/api/dda/hierarchy/tree');
-    libraryTreeData = tree;
-    sel.innerHTML = (tree.zones || []).map((z) =>
-      `<option value="${z.id}">${escapeHtml(z.name)}</option>`
-    ).join('');
-    populateManageFolders();
-  } catch (err) {
-    showDdaError?.(err.message);
-  }
-}
-
-function populateManageFolders() {
-  const zoneId = parseInt(document.getElementById('manage-zone-select')?.value || '0', 10);
-  const folderSel = document.getElementById('manage-folder-select');
-  if (!folderSel || !libraryTreeData) return;
-  const zone = (libraryTreeData.zones || []).find((z) => z.id === zoneId);
-  folderSel.innerHTML = (zone?.folders || []).map((f) =>
-    `<option value="${f.id}">${escapeHtml(f.name)}</option>`
-  ).join('');
-}
-
-document.getElementById('btn-manage-library')?.addEventListener('click', openManageModal);
-document.getElementById('dda-manage-close')?.addEventListener('click', closeManageModal);
-document.getElementById('manage-zone-select')?.addEventListener('change', populateManageFolders);
-
-document.getElementById('btn-add-zone')?.addEventListener('click', async () => {
-  const name = document.getElementById('manage-zone-name')?.value?.trim();
-  if (!name) return showDdaError?.('Enter a zone name.');
-  try {
-    await ddaApi('POST', '/api/dda/hierarchy/zones', { body: JSON.stringify({ name }) });
-    document.getElementById('manage-zone-name').value = '';
-    showDdaSuccess?.('Zone created.');
-    await loadLibraryTree();
-    await populateManageZones();
-    if (typeof populateUploadZones === 'function') populateUploadZones();
-  } catch (err) {
-    showDdaError?.(err.message);
-  }
-});
-
-document.getElementById('btn-rename-zone')?.addEventListener('click', async () => {
-  const zoneId = parseInt(document.getElementById('manage-zone-select')?.value || '0', 10);
-  const name = document.getElementById('manage-zone-rename')?.value?.trim();
-  if (!zoneId || !name) return showDdaError?.('Select a zone and enter a new name.');
-  try {
-    await ddaApi('PATCH', `/api/dda/hierarchy/zones/${zoneId}`, { body: JSON.stringify({ name }) });
-    document.getElementById('manage-zone-rename').value = '';
-    showDdaSuccess?.('Zone renamed.');
-    await loadLibraryTree();
-    await populateManageZones();
-    if (typeof populateUploadZones === 'function') populateUploadZones();
-  } catch (err) {
-    showDdaError?.(err.message);
-  }
-});
-
-document.getElementById('btn-add-folder')?.addEventListener('click', async () => {
-  const zoneId = parseInt(document.getElementById('manage-zone-select')?.value || '0', 10);
-  const name = document.getElementById('manage-folder-name')?.value?.trim();
-  if (!zoneId || !name) return showDdaError?.('Select a zone and enter a folder name.');
-  try {
-    await ddaApi('POST', `/api/dda/hierarchy/zones/${zoneId}/folders`, { body: JSON.stringify({ name }) });
-    document.getElementById('manage-folder-name').value = '';
-    showDdaSuccess?.('Folder created.');
-    await loadLibraryTree();
-    await populateManageZones();
-    if (typeof populateUploadZones === 'function') populateUploadZones();
-  } catch (err) {
-    showDdaError?.(err.message);
-  }
-});
-
-document.getElementById('btn-rename-folder')?.addEventListener('click', async () => {
-  const folderId = parseInt(document.getElementById('manage-folder-select')?.value || '0', 10);
-  const name = document.getElementById('manage-folder-rename')?.value?.trim();
-  if (!folderId || !name) return showDdaError?.('Select a folder and enter a new name.');
-  try {
-    await ddaApi('PATCH', `/api/dda/hierarchy/folders/${folderId}`, { body: JSON.stringify({ name }) });
-    document.getElementById('manage-folder-rename').value = '';
-    showDdaSuccess?.('Folder renamed.');
-    await loadLibraryTree();
-    await populateManageZones();
-    if (typeof populateUploadZones === 'function') populateUploadZones();
-  } catch (err) {
-    showDdaError?.(err.message);
-  }
-});
-
-document.getElementById('btn-create-year')?.addEventListener('click', async () => {
-  const folderId = parseInt(document.getElementById('manage-folder-select')?.value || '0', 10);
-  const year = parseInt(document.getElementById('manage-year')?.value || '0', 10);
-  if (!folderId || !year) return showDdaError?.('Select a folder and enter a year.');
-  try {
-    await ddaApi('POST', `/api/dda/hierarchy/folders/${folderId}/years`, { body: JSON.stringify({ year }) });
-    showDdaSuccess?.(`Year folder ${year} created.`);
-    await loadLibraryTree();
-  } catch (err) {
-    showDdaError?.(err.message);
-  }
-});
-
-document.getElementById('btn-delete-folder')?.addEventListener('click', async () => {
-  const folderId = parseInt(document.getElementById('manage-folder-select')?.value || '0', 10);
-  if (!folderId || !confirm('Delete this empty folder?')) return;
-  try {
-    await ddaApi('DELETE', `/api/dda/hierarchy/folders/${folderId}`);
-    showDdaSuccess?.('Folder deleted.');
-    await loadLibraryTree();
-    await populateManageZones();
-  } catch (err) {
-    showDdaError?.(err.message);
-  }
-});
-
-document.getElementById('btn-delete-zone')?.addEventListener('click', async () => {
-  const zoneId = parseInt(document.getElementById('manage-zone-select')?.value || '0', 10);
-  if (!zoneId || !confirm('Delete this empty zone and all empty folders?')) return;
-  try {
-    await ddaApi('DELETE', `/api/dda/hierarchy/zones/${zoneId}`);
-    showDdaSuccess?.('Zone deleted.');
-    await loadLibraryTree();
-    await populateManageZones();
-  } catch (err) {
-    showDdaError?.(err.message);
-  }
-});
-
-/* ---- Reassign legacy images ---- */
-
-function openReassignModal(imagePath, filename) {
-  const modal = document.getElementById('dda-reassign-modal');
-  if (!modal) return;
-  modal.dataset.path = imagePath;
-  document.getElementById('reassign-filename').textContent = filename || imagePath;
-  populateReassignPickers();
-  modal.classList.remove('hidden');
-}
-
-function closeReassignModal() {
-  document.getElementById('dda-reassign-modal')?.classList.add('hidden');
-}
-
-async function populateReassignPickers() {
-  const zoneSel = document.getElementById('reassign-zone');
-  const folderSel = document.getElementById('reassign-folder');
-  if (!zoneSel) return;
-  try {
-    const tree = await ddaApi('GET', '/api/dda/hierarchy/tree');
-    zoneSel.innerHTML = (tree.zones || []).filter((z) => z.slug !== '_unassigned').map((z) =>
-      `<option value="${z.id}">${escapeHtml(z.name)}</option>`
-    ).join('');
-    const syncFolders = () => {
-      const zoneId = parseInt(zoneSel.value, 10);
-      const zone = (tree.zones || []).find((z) => z.id === zoneId);
-      folderSel.innerHTML = (zone?.folders || []).map((f) =>
-        `<option value="${f.id}">${escapeHtml(f.name)}</option>`
-      ).join('');
-    };
-    zoneSel.onchange = syncFolders;
-    syncFolders();
-  } catch (_) {}
-}
-
-document.getElementById('dda-reassign-close')?.addEventListener('click', closeReassignModal);
-document.getElementById('btn-reassign-submit')?.addEventListener('click', async () => {
-  const modal = document.getElementById('dda-reassign-modal');
-  const path = modal?.dataset.path;
-  const zoneId = parseInt(document.getElementById('reassign-zone')?.value || '0', 10);
-  const folderId = parseInt(document.getElementById('reassign-folder')?.value || '0', 10);
-  const year = parseInt(document.getElementById('reassign-year')?.value || '0', 10);
-  if (!path || !zoneId || !folderId || !year) return;
-  try {
-    await ddaApi('POST', '/api/dda/local/reassign', {
-      body: JSON.stringify({ path, zone_id: zoneId, folder_id: folderId, year }),
-    });
-    showDdaSuccess?.('Image reassigned.');
-    closeReassignModal();
-    await window.ddaState.rescan();
-  } catch (err) {
-    showDdaError?.(err.message);
-  }
-});
-
-window.openReassignModal = openReassignModal;

static/js/dda/library.js

@@ -1,106 +1,37 @@
-let uploadTreeCache = null;
+function renderYearTree(years) {
+  const tree = document.getElementById('lib-tree');
+  if (!tree) return;
+  const filter = (document.getElementById('lib-tree-search')?.value || '').toLowerCase();
 
-async function populateUploadZones() {
-  const zoneSel = document.getElementById('upload-zone');
-  if (!zoneSel) return;
-  try {
-    const tree = await ddaApi('GET', '/api/dda/hierarchy/tree');
-    uploadTreeCache = tree;
-    zoneSel.innerHTML = '<option value="">— Select zone —</option>' +
-      (tree.zones || []).filter((z) => z.slug !== '_unassigned').map((z) =>
-        `<option value="${z.id}">${escapeHtml(z.name)}</option>`
-      ).join('');
-    populateUploadFolders();
-    syncUploadPickers();
-  } catch (_) {}
-}
-
-function populateUploadFolders() {
-  const zoneId = parseInt(document.getElementById('upload-zone')?.value || '0', 10);
-  const folderSel = document.getElementById('upload-folder');
-  if (!folderSel || !uploadTreeCache) return;
-  const zone = (uploadTreeCache.zones || []).find((z) => z.id === zoneId);
-  folderSel.innerHTML = '<option value="">— Select folder —</option>' +
-    (zone?.folders || []).map((f) =>
-      `<option value="${f.id}">${escapeHtml(f.name)}</option>`
-    ).join('');
-}
-
-function syncUploadPickers() {
-  const s = window.ddaState?.selection;
-  if (!s) return;
-  const zoneSel = document.getElementById('upload-zone');
-  const folderSel = document.getElementById('upload-folder');
-  const yearInput = document.getElementById('upload-year');
-  if (s.zoneId && zoneSel) {
-    zoneSel.value = String(s.zoneId);
-    populateUploadFolders();
-  }
-  if (s.folderId && folderSel) folderSel.value = String(s.folderId);
-  if (s.year && yearInput) yearInput.value = String(s.year);
-}
+  const allBtn = `
+    <button type="button" class="dda-tree-year ${window.ddaState.selectedYear === null ? 'active' : ''}" data-year="">
+      All years
+    </button>`;
 
-document.getElementById('upload-zone')?.addEventListener('change', populateUploadFolders);
+  const yearBtns = (years || [])
+    .filter((y) => !filter || String(y.year).includes(filter))
+    .map((y) => `
+      <button type="button" class="dda-tree-year ${window.ddaState.selectedYear === y.year ? 'active' : ''}" data-year="${y.year}">
+        ${y.year} <span class="dim">(${y.imageCount})</span>
+      </button>`).join('');
 
-function bindUploadForm(formId, fileId, btnId) {
-  document.getElementById(formId)?.addEventListener('submit', async (e) => {
-    e.preventDefault();
-    hideDdaError?.();
-    const fileInput = document.getElementById(fileId);
-    const file = fileInput?.files?.[0];
-    if (!file) {
-      showDdaError?.('Select a .tif file.');
-      return;
-    }
+  tree.innerHTML = allBtn + yearBtns;
 
-    const zoneId = document.getElementById('upload-zone')?.value;
-    const folderId = document.getElementById('upload-folder')?.value;
-    const year = document.getElementById('upload-year')?.value;
-    if (!zoneId || !folderId || !year) {
-      showDdaError?.('Select zone, folder, and year.');
-      return;
-    }
-
-    const maxBytes = window.ddaState?.localCfg?.maxGeotiffBytes
-      || (window.ddaState?.localCfg?.maxGeotiffMb || 5120) * 1024 * 1024;
-    if (file.size > maxBytes) {
-      showDdaError?.(`File is ${formatBytes(file.size)} — maximum upload size is ${formatBytes(maxBytes)}.`);
-      return;
-    }
-
-    const form = new FormData();
-    form.append('file', file);
-    form.append('zone_id', zoneId);
-    form.append('folder_id', folderId);
-    form.append('year', year);
-
-    const btn = document.getElementById(btnId);
-    const progWrap = document.getElementById('upload-progress');
-    const progFill = document.getElementById('upload-progress-fill');
-    const progLabel = document.getElementById('upload-progress-label');
-
-    btn.disabled = true;
-    progWrap?.classList.remove('hidden');
-    if (progFill) progFill.style.width = '0%';
-
-    try {
-      await uploadWithProgress('/api/dda/local/upload', form, (loaded, total) => {
-        const pct = total ? Math.round((loaded / total) * 100) : 0;
-        if (progFill) progFill.style.width = pct + '%';
-        if (progLabel) progLabel.textContent = `Uploading… ${pct}% (${formatBytes(loaded)} / ${formatBytes(total)})`;
-      });
-      showDdaSuccess?.('Uploaded to library. Refreshing…');
-      fileInput.value = '';
-      await window.ddaState.rescan();
-    } catch (err) {
-      showDdaError?.(err.message || 'Upload failed.');
-    } finally {
-      btn.disabled = false;
-      setTimeout(() => progWrap?.classList.add('hidden'), 2000);
-    }
+  tree.querySelectorAll('.dda-tree-year').forEach((btn) => {
+    btn.addEventListener('click', () => {
+      tree.querySelectorAll('.dda-tree-year').forEach((b) => b.classList.remove('active'));
+      btn.classList.add('active');
+      const raw = btn.dataset.year;
+      window.ddaState.setYear(raw ? parseInt(raw, 10) : null);
+      window.ddaState.refreshImages();
+    });
   });
 }
 
+document.getElementById('lib-tree-search')?.addEventListener('input', () => {
+  if (window.ddaState?.years) renderYearTree(window.ddaState.years);
+});
+
 function uploadWithProgress(url, formData, onProgress) {
   return new Promise((resolve, reject) => {
     const xhr = new XMLHttpRequest();
@@ -120,7 +51,55 @@ function uploadWithProgress(url, formData, onProgress) {
   });
 }
 
-bindUploadForm('form-hf-upload', 'hf-file', 'btn-hf-upload');
+function formatBytes(n) {
+  if (n >= 1024 ** 3) return (n / 1024 ** 3).toFixed(1) + ' GB';
+  if (n >= 1024 ** 2) return (n / 1024 ** 2).toFixed(1) + ' MB';
+  return (n / 1024).toFixed(0) + ' KB';
+}
+
+document.getElementById('form-hf-upload')?.addEventListener('submit', async (e) => {
+  e.preventDefault();
+  hideDdaError?.();
+  const fileInput = document.getElementById('hf-file');
+  const file = fileInput?.files?.[0];
+  if (!file) {
+    showDdaError?.('Select a .tif file.');
+    return;
+  }
+
+  const maxBytes = window.ddaState?.localCfg?.maxGeotiffBytes
+    || (window.ddaState?.localCfg?.maxGeotiffMb || 5120) * 1024 * 1024;
+  if (file.size > maxBytes) {
+    showDdaError?.(`File is ${formatBytes(file.size)} — maximum upload size is ${formatBytes(maxBytes)}.`);
+    return;
+  }
+
+  const form = new FormData();
+  form.append('file', file);
+  form.append('year', document.getElementById('hf-year').value);
+
+  const btn = document.getElementById('btn-hf-upload');
+  const progWrap = document.getElementById('hf-upload-progress');
+  const progFill = document.getElementById('hf-upload-progress-fill');
+  const progLabel = document.getElementById('hf-upload-progress-label');
+
+  btn.disabled = true;
+  progWrap?.classList.remove('hidden');
+  if (progFill) progFill.style.width = '0%';
 
-window.populateUploadZones = populateUploadZones;
-window.syncUploadPickers = syncUploadPickers;
+  try {
+    await uploadWithProgress('/api/dda/local/upload', form, (loaded, total) => {
+      const pct = total ? Math.round((loaded / total) * 100) : 0;
+      if (progFill) progFill.style.width = pct + '%';
+      if (progLabel) progLabel.textContent = `Uploading… ${pct}% (${formatBytes(loaded)} / ${formatBytes(total)})`;
+    });
+    showDdaSuccess?.('Uploaded to Space library. Click Refresh if images do not appear.');
+    fileInput.value = '';
+    await window.ddaState.rescan();
+  } catch (err) {
+    showDdaError?.(err.message || 'Upload failed. Large files may exceed HF timeout — try a smaller file or run locally.');
+  } finally {
+    btn.disabled = false;
+    setTimeout(() => progWrap?.classList.add('hidden'), 2000);
+  }
+});

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=12" />
+  <link rel="stylesheet" href="/static/css/dda.css?v=11" />
 </head>
 <body>
   <div class="app dda-app">
@@ -32,60 +32,53 @@
     <div id="dda-error" class="alert alert-error hidden"></div>
     <div id="dda-success" class="alert alert-success hidden"></div>
 
-    <!-- Tab: Image Library — zone/folder/year hierarchy under library_sources/ -->
+    <!-- Tab: Image Library — reads from library_sources/ year folders -->
     <section id="tab-library" class="dda-panel active" role="tabpanel">
       <div class="dda-layout">
         <aside class="dda-sidebar card">
           <div class="card-header">
-            <h3>Library</h3>
-            <div class="dda-sidebar-actions">
-              <button type="button" class="btn btn-secondary btn-sm hidden" id="btn-manage-library" title="Manage zones and folders">Manage</button>
-              <button type="button" class="btn btn-secondary btn-sm" id="btn-refresh-lib" title="Rescan folder">Refresh</button>
-            </div>
+            <h3>Years</h3>
+            <button type="button" class="btn btn-secondary btn-sm" id="btn-refresh-lib" title="Rescan folder">Refresh</button>
           </div>
           <div id="lib-folder-path" class="dda-folder-path dim"></div>
-          <input type="search" id="lib-tree-search" class="dda-search" placeholder="Filter zones, folders, years…" />
+          <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">
             <div class="card-header">
-              <h3>Folder library</h3>
+              <h3>Local folder library</h3>
               <span class="dim" id="lib-config-hint"></span>
             </div>
             <p class="sub" id="lib-instructions">
-              Organize images as <code>library_sources/{zone}/{folder}/{year}/</code>, then click <strong>Refresh</strong>.
+              Copy <code>.tif</code> images into <code>library_sources/YEAR/</code> in your project folder, then click <strong>Refresh</strong>.
             </p>
             <pre id="lib-path-display" class="dda-path-code"></pre>
           </div>
-          <div class="card" id="upload-card">
+          <div class="card hidden" id="hf-upload-card">
             <div class="card-header">
-              <h3 id="upload-card-title">Upload to library</h3>
-              <span class="dim" id="upload-card-hint"></span>
+              <h3>Upload to Space storage</h3>
+              <span class="dim">Required on Hugging Face</span>
             </div>
-            <p class="sub" id="hf-upload-limit">Select zone, folder, and year before uploading.</p>
+            <p class="sub" id="hf-upload-limit">Files on your computer are not on the server. Upload .tif images here (up to 5 GB each).</p>
             <form id="form-hf-upload" class="dda-upload-form">
               <div class="location-row">
                 <div class="form-group">
-                  <label for="upload-zone">Zone</label>
-                  <select id="upload-zone" required><option value="">— Select zone —</option></select>
-                </div>
-                <div class="form-group">
-                  <label for="upload-folder">Folder</label>
-                  <select id="upload-folder" required><option value="">— Select folder —</option></select>
-                </div>
-                <div class="form-group">
-                  <label for="upload-year">Year</label>
-                  <input type="number" id="upload-year" required min="1990" max="2100" value="2025" />
+                  <label for="hf-year">Year folder</label>
+                  <input type="number" id="hf-year" required min="2000" max="2100" value="2025" />
                 </div>
                 <div class="form-group">
                   <label for="hf-file">GeoTIFF file</label>
-                  <input type="file" id="hf-file" accept=".tif,.tiff,.png,.jpg,.jpeg" required />
+                  <input type="file" id="hf-file" accept=".tif,.tiff" required />
                 </div>
               </div>
-              <div id="upload-progress" class="dda-upload-progress hidden">
-                <div class="dda-progress-bar"><div id="upload-progress-fill" class="dda-progress-fill"></div></div>
-                <span id="upload-progress-label" class="dim">Uploading…</span>
+              <div id="hf-upload-progress" class="dda-upload-progress hidden">
+                <div class="dda-progress-bar"><div id="hf-upload-progress-fill" class="dda-progress-fill"></div></div>
+                <span id="hf-upload-progress-label" class="dim">Uploading…</span>
               </div>
               <button type="submit" class="btn btn-primary" id="btn-hf-upload">Upload to library</button>
             </form>
@@ -95,7 +88,7 @@
               <h3 id="lib-grid-title">Images</h3>
               <input type="search" id="lib-filter" class="dda-search" placeholder="Search filenames…" />
             </div>
-            <div id="lib-grid" class="dda-grid"><p class="dim">Select a zone, folder, or year in the sidebar.</p></div>
+            <div id="lib-grid" class="dda-grid"><p class="dim">Select a year or add images to library_sources/.</p></div>
           </div>
         </main>
       </div>
@@ -266,76 +259,8 @@
     </div>
   </div>
 
-  <div id="dda-manage-modal" class="dda-modal hidden" role="dialog" aria-modal="true">
-    <div class="dda-modal-panel card dda-manage-panel">
-      <div class="card-header">
-        <h3>Manage library structure</h3>
-        <button type="button" class="btn btn-secondary btn-sm" id="dda-manage-close">Close</button>
-      </div>
-      <div class="dda-manage-section">
-        <h4>Zones</h4>
-        <div class="location-row">
-          <input type="text" id="manage-zone-name" placeholder="New zone name" />
-          <button type="button" class="btn btn-primary btn-sm" id="btn-add-zone">Add zone</button>
-        </div>
-        <div class="location-row">
-          <select id="manage-zone-select"></select>
-          <input type="text" id="manage-zone-rename" placeholder="Rename selected zone" />
-          <button type="button" class="btn btn-secondary btn-sm" id="btn-rename-zone">Rename</button>
-          <button type="button" class="btn btn-secondary btn-sm" id="btn-delete-zone">Delete</button>
-        </div>
-      </div>
-      <div class="dda-manage-section">
-        <h4>Folders</h4>
-        <div class="location-row">
-          <input type="text" id="manage-folder-name" placeholder="New folder name" />
-          <button type="button" class="btn btn-primary btn-sm" id="btn-add-folder">Add folder</button>
-        </div>
-        <div class="location-row">
-          <select id="manage-folder-select"></select>
-          <input type="text" id="manage-folder-rename" placeholder="Rename selected folder" />
-          <button type="button" class="btn btn-secondary btn-sm" id="btn-rename-folder">Rename</button>
-          <button type="button" class="btn btn-secondary btn-sm" id="btn-delete-folder">Delete</button>
-        </div>
-      </div>
-      <div class="dda-manage-section">
-        <h4>Year folder</h4>
-        <div class="location-row">
-          <input type="number" id="manage-year" min="1990" max="2100" value="2025" />
-          <button type="button" class="btn btn-secondary btn-sm" id="btn-create-year">Create year folder</button>
-        </div>
-      </div>
-    </div>
-  </div>
-
-  <div id="dda-reassign-modal" class="dda-modal hidden" role="dialog" aria-modal="true">
-    <div class="dda-modal-panel card">
-      <div class="card-header">
-        <h3>Assign location</h3>
-        <button type="button" class="btn btn-secondary btn-sm" id="dda-reassign-close">Close</button>
-      </div>
-      <p class="sub">Move <strong id="reassign-filename"></strong> to:</p>
-      <div class="location-row">
-        <div class="form-group">
-          <label for="reassign-zone">Zone</label>
-          <select id="reassign-zone"></select>
-        </div>
-        <div class="form-group">
-          <label for="reassign-folder">Folder</label>
-          <select id="reassign-folder"></select>
-        </div>
-        <div class="form-group">
-          <label for="reassign-year">Year</label>
-          <input type="number" id="reassign-year" min="1990" max="2100" value="2025" />
-        </div>
-      </div>
-      <button type="button" class="btn btn-primary" id="btn-reassign-submit">Move image</button>
-    </div>
-  </div>
-
-  <script src="/static/js/dda/app.js?v=13"></script>
-  <script src="/static/js/dda/hierarchy.js?v=1"></script>
-  <script src="/static/js/dda/library.js?v=7"></script>
+  <script src="/static/js/dda/app.js?v=12"></script>
+  <script src="/static/js/dda/library.js?v=6"></script>
   <script src="/static/js/dda/result.js?v=6"></script>
   <script src="/static/js/dda/compare.js?v=9"></script>
   <script src="/static/js/dda/reports.js?v=4"></script>