Add zone-aware library organization for dev DDA uploads.

Unify disk layout and DB hierarchy as zone/folder/year paths, with CRUD APIs, upload assignment, legacy migration, and a navigable library tree in the UI.

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

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 year folders (default: `library_sources/` in project) |
+| `LOCAL_LIBRARY_ROOT` | Path to library root (default: `library_sources/` or `data/library_sources/` on HF) |
 | `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,20 +148,44 @@ 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** — 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
+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
 
 Sign-off: DDA stakeholder approves sample runs on dev Space before any push to `satdetect` production.
 

app/dda/bootstrap.py

@@ -4,8 +4,9 @@ from fastapi import FastAPI
 from sqlalchemy import text as sa_text
 
 from ..database import engine
-from .config import IS_DDA_MODE, ensure_library_dirs, ensure_local_year_folders, is_hf_hosted
+from .config import IS_DDA_MODE, ensure_library_dirs, 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
@@ -23,12 +24,13 @@ 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))
@@ -43,14 +45,37 @@ 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 SessionLocal
+    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)
+
     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:
@@ -58,11 +83,17 @@ def init_dda_database():
 
     try:
         from .local_library import library_debug_info, scan_images
-        info = library_debug_info()
+        from ..database import SessionLocal as SL
+        sdb = SL()
+        try:
+            info = library_debug_info(db=sdb)
+            total = len(scan_images(db=sdb))
+        finally:
+            sdb.close()
         logger.info(
             "DDA library ready (hosted=%s): %d images, writable=%s",
             is_hf_hosted(),
-            len(scan_images()),
+            total,
             info.get("roots", [{}])[0].get("path") if info.get("roots") else "?",
         )
     except Exception as exc:
@@ -79,5 +110,6 @@ 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, local)")
+    logger.info("APP_MODE=dda — DDA routes enabled (library, jobs, reports, review, training, admin, hierarchy, local)")

app/dda/hierarchy_routes.py

@@ -0,0 +1,253 @@
+"""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

@@ -0,0 +1,148 @@
+"""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,34 +86,8 @@ def dda_config():
 @router.get("/hierarchy")
 def get_hierarchy(db: Session = Depends(get_db)):
     _require_dda()
-    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}
+    from .local_library import scan_tree
+    return scan_tree(db)
 
 
 @router.get("/images")

app/dda/local_library.py

@@ -1,67 +1,169 @@
 """
-Read satellite/drone images from local year-based folders.
+Read satellite/drone images from zone/folder/year hierarchy under library_sources/.
 
-Folder layout (under library_sources/):
+Canonical layout:
 
     library_sources/
-      2024/
-        image_a.tif
-      2025/
-        image_c.tif
+      central_delhi/
+        site_a/
+          2024/
+            image_a.tif
+      _unassigned/
+        legacy/
+          2025/
+            old_image.tif
 
-Copy files into library_sources/YEAR/ in the project folder (or data/library_sources/ on HF).
+Legacy flat library_sources/YEAR/ is still scanned (tagged legacy=true) until migrated.
 """
 from __future__ import annotations
 
 import hashlib
 import logging
-from dataclasses import dataclass
+from dataclasses import dataclass, field
 from pathlib import Path
-from typing import List, Optional
+from typing import Dict, List, Optional, Tuple
 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  # relative posix path, e.g. 2025/aerial.tif
+    path: str
     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 _iter_image_files(root: Path, year: Optional[int] = None):
+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):
     if not root.exists():
         return
-    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():
+
+    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:
                 continue
-            ext = path.suffix.lower()
-            if ext not in ALLOWED_EXTENSIONS:
-                logger.debug("Skipped (extension %s): %s", ext, path)
+            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():
                 continue
-            yield root, y, path
+            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
 
 
 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")
@@ -76,35 +178,35 @@ def safe_resolve(relative_path: str) -> Path:
     raise HTTPException(status_code=404, detail="Image file not found")
 
 
-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."""
+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]:
     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 in _iter_image_files(root, year=year):
-            rel = path.relative_to(r).as_posix()
+        for (r, y, path, rel, zid, zname, fid, fname, legacy) in _iter_all_images(root, lookup, year_filter=year):
             if rel in seen_paths:
                 continue
-            if q and q not in rel.lower():
+            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():
                 continue
             try:
                 size = path.stat().st_size
@@ -118,13 +220,109 @@ def scan_images(year: Optional[int] = None, query: Optional[str] = None) -> List
                     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,
@@ -133,6 +331,12 @@ 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:
@@ -175,28 +379,42 @@ def ensure_root() -> None:
     LOCAL_THUMB_CACHE.mkdir(parents=True, exist_ok=True)
 
 
-def library_debug_info() -> dict:
-    """Diagnostics for troubleshooting missing images."""
+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:
     roots_info = []
     for root in get_library_roots():
-        info = {
-            "path": str(root),
-            "exists": root.exists(),
-            "years": [],
-            "otherFiles": [],
-        }
+        info = {"path": str(root), "exists": root.exists(), "zones": [], "legacyYears": []}
         if root.exists():
             for entry in sorted(root.iterdir()):
                 if entry.is_dir() and _is_year_dir(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)
+                    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)
         roots_info.append(info)
     return {
         "roots": roots_info,
         "allowedExtensions": sorted(ALLOWED_EXTENSIONS),
-        "totalImages": len(scan_images()),
+        "totalImages": len(scan_images(db=db)),
     }

app/dda/local_routes.py

@@ -1,11 +1,13 @@
-"""API for reading images from local library_sources/ year folders."""
+"""API for reading images from local library_sources/ zone/folder/year hierarchy."""
 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
@@ -25,13 +27,16 @@ 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__)
@@ -53,6 +58,31 @@ 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()
@@ -61,13 +91,13 @@ def local_library_config():
     hosted = is_hf_hosted()
     if hosted:
         instructions = (
-            "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."
+            "Upload images below with zone, folder, and year. Files are saved under "
+            "library_sources/{zone}/{folder}/{year}/ on persistent Space storage."
         )
     else:
         instructions = (
-            "Copy .tif images into library_sources/YEAR/ in your project folder, then Refresh. "
-            "Or use Upload to save into data/library_sources/."
+            "Copy .tif images into library_sources/{zone}/{folder}/{year}/, or use Upload "
+            "with zone and folder selected. Click Refresh after adding files manually."
         )
     return {
         "source": "local_folder",
@@ -87,36 +117,49 @@ def local_library_config():
 
 
 @router.get("/local/debug")
-def local_debug():
+def local_debug(db: Session = Depends(get_db)):
     _require_dda()
-    return library_debug_info()
+    return library_debug_info(db=db)
 
 
 @router.get("/local/years")
-def 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)):
     _require_dda()
-    return {"years": scan_years(), "rootPaths": [str(r) for r in get_library_roots()]}
+    return scan_tree(db)
 
 
 @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(year=year, query=q)
+    entries = scan_images(
+        db=db, year=year, zone_id=zone_id, folder_id=folder_id,
+        query=q, legacy_only=legacy_only,
+    )
     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. 2025/aerial.tif")):
+def local_image_detail(path: str = Query(..., description="Relative path e.g. zone/folder/2025/aerial.tif"), db: Session = Depends(get_db)):
     _require_dda()
-    entries = scan_images()
+    entries = scan_images(db=db)
     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() if e.path == norm), None)
+        match = next((e for e in scan_images(db=db) 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)
@@ -144,16 +187,25 @@ 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 persistent library_sources/YEAR/ (required on HF)."""
+    """Upload GeoTIFF into library_sources/{zone}/{folder}/{year}/."""
     _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
@@ -161,40 +213,79 @@ async def local_upload(
         raise HTTPException(status_code=400, detail=f"Allowed: {', '.join(sorted(ALLOWED_EXTENSIONS))}")
 
     root = get_writable_library_root()
-    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
-
+    dest = build_upload_dest(root, zone.slug, folder.slug, year, original)
     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)
 
-    entries = scan_images(year=year)
+    _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)
     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": f"{year}/{dest.name}",
+        "path": rel,
         "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():
+def local_rescan(db: Session = Depends(get_db)):
     _require_dda()
-    years = scan_years()
-    total = sum(y["imageCount"] for y in years)
-    info = library_debug_info()
+    tree = scan_tree(db)
+    total = len(scan_images(db=db))
+    years = scan_years(db=db)
+    info = library_debug_info(db=db)
     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()],
@@ -220,7 +311,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 (e.g. 2025/aerial.tif)."""
+    """Run change detection on two library images by relative path."""
     _require_dda()
     base_norm = base_path.replace("\\", "/").strip()
     comp_norm = comparison_path.replace("\\", "/").strip()
@@ -245,7 +336,6 @@ 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,6 +16,7 @@ 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)
 
@@ -23,17 +24,35 @@ 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

@@ -0,0 +1,48 @@
+"""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,6 +3,7 @@ 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__)
@@ -12,17 +13,25 @@ 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():
-        zone = DdaZone(name=zone_name, mode="admin")
+        slug = unique_slug(zone_name, zone_slugs)
+        zone_slugs.add(slug)
+        zone = DdaZone(name=zone_name, slug=slug, mode="admin")
         db.add(zone)
         db.flush()
         zones_created += 1
+        folder_slugs: set = set()
         for village_name in villages:
-            db.add(DdaVillage(zone_id=zone.id, name=village_name))
+            fslug = unique_slug(village_name, folder_slugs)
+            folder_slugs.add(fslug)
+            db.add(DdaVillage(zone_id=zone.id, name=village_name, slug=fslug))
             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  # noqa: F401
+from .dda.models import DdaZone, DdaVillage, ImageAsset, DetectionJob, RegionReview, DdaLocalFileIndex  # 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,6 +83,43 @@
   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,15 +55,32 @@ function formatBytes(n) {
 }
 
 let ddaConfig = null;
-let localYears = [];
-let selectedYear = null;
+let libraryTree = null;
+const selection = { zoneId: null, zoneName: '', folderId: null, folderName: '', year: null, legacy: false };
 
 window.ddaState = {
   get config() { return ddaConfig; },
   get localCfg() { return window._localCfg; },
-  get years() { return localYears; },
-  get selectedYear() { return selectedYear; },
-  setYear(year) { selectedYear = year; },
+  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;
+  },
   refreshImages: () => loadLibraryImages(),
   rescan: () => rescanLibrary(),
 };
@@ -83,8 +100,8 @@ document.querySelectorAll('.dda-tab').forEach((btn) => {
 
 async function rescanLibrary() {
   const data = await ddaApi('POST', '/api/dda/local/rescan');
-  localYears = data.years || [];
-  if (typeof renderYearTree === 'function') renderYearTree(localYears);
+  libraryTree = data.tree || null;
+  if (typeof renderLibraryTree === 'function' && libraryTree) renderLibraryTree(libraryTree);
   await loadLibraryImages();
   return data;
 }
@@ -96,6 +113,13 @@ 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';
@@ -106,6 +130,7 @@ 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');
     }
@@ -118,8 +143,17 @@ async function initDda() {
     const instr = document.getElementById('lib-instructions');
     if (instr && localCfg.instructions) instr.textContent = localCfg.instructions;
 
-    const hfUpload = document.getElementById('hf-upload-card');
-    if (hfUpload) hfUpload.classList.toggle('hidden', !localCfg.isHosted);
+    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 resHint = document.getElementById('dda-detect-res-hint');
     if (resHint && localCfg.detectionMaxSide) {
@@ -128,7 +162,7 @@ async function initDda() {
 
     const uploadLimit = document.getElementById('hf-upload-limit');
     if (uploadLimit && localCfg.maxUploadGb) {
-      uploadLimit.textContent = `Files on your computer are not on the server. Upload .tif images here (up to ${localCfg.maxUploadGb} GB each).`;
+      uploadLimit.textContent = `Select zone, folder, and year. Upload .tif images (up to ${localCfg.maxUploadGb} GB each).`;
     }
 
     const appMode = ddaConfig.appMode || ddaConfig.mode || localCfg.appMode || 'dda';
@@ -141,76 +175,61 @@ async function initDda() {
       document.querySelector(`.dda-tab[data-tab="${urlTab}"]`)?.click();
     }
 
-    const yearsData = await ddaApi('GET', '/api/dda/local/years');
-    localYears = yearsData.years || [];
-    if (typeof renderYearTree === 'function') renderYearTree(localYears);
+    libraryTree = await (typeof loadLibraryTree === 'function' ? loadLibraryTree() : null);
+    if (typeof populateUploadZones === 'function') await populateUploadZones();
     await loadLibraryImages();
-    await loadHierarchyTree();
   } catch (err) {
     showDdaError(err.message || 'Failed to load library');
   }
 }
 
-async function loadHierarchyTree() {
-  const el = document.getElementById('lib-hierarchy');
-  if (!el) return;
-  try {
-    const data = await ddaApi('GET', '/api/dda/hierarchy');
-    const zones = data.zones || [];
-    if (!zones.length) {
-      el.innerHTML = '<p class="dim">No zones seeded.</p>';
-      return;
-    }
-    el.innerHTML = `<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>';
-  }
+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';
 }
 
-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 (selectedYear) params.set('year', String(selectedYear));
-  if (q) params.set('q', q);
-  if (title) {
-    title.textContent = selectedYear ? `Images — ${selectedYear}` : 'Images — all years';
+  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 (q) params.set('q', q);
+  if (title) title.textContent = `Images — ${selectionTitle()}`;
   try {
     const items = await ddaApi('GET', '/api/dda/local/images?' + params.toString());
     window.ddaState.libraryItems = items;
     if (!items.length) {
-      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>`;
+      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>`;
       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">
-          <strong>${escapeHtml(String(img.year))}</strong><br/>
-          ${escapeHtml(img.filename)}<br/>
+          <span class="dim dda-crumb">${escapeHtml(crumb)}</span><br/>
           <span class="dim">${formatBytes(img.fileSizeBytes)}</span>
+          ${assignBtn}
         </div>
       </div>`;
     }).join('');
@@ -220,6 +239,14 @@ 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

@@ -0,0 +1,359 @@
+/** 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,37 +1,106 @@
-function renderYearTree(years) {
-  const tree = document.getElementById('lib-tree');
-  if (!tree) return;
-  const filter = (document.getElementById('lib-tree-search')?.value || '').toLowerCase();
+let uploadTreeCache = null;
 
-  const allBtn = `
-    <button type="button" class="dda-tree-year ${window.ddaState.selectedYear === null ? 'active' : ''}" data-year="">
-      All years
-    </button>`;
+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 (_) {}
+}
 
-  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 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('');
+}
 
-  tree.innerHTML = allBtn + yearBtns;
+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);
+}
 
-  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('upload-zone')?.addEventListener('change', populateUploadFolders);
+
+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;
+    }
+
+    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);
+    }
   });
 }
 
-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();
@@ -51,55 +120,7 @@ function uploadWithProgress(url, formData, onProgress) {
   });
 }
 
-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%';
+bindUploadForm('form-hf-upload', 'hf-file', 'btn-hf-upload');
 
-  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);
-  }
-});
+window.populateUploadZones = populateUploadZones;
+window.syncUploadPickers = syncUploadPickers;

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=11" />
+  <link rel="stylesheet" href="/static/css/dda.css?v=12" />
 </head>
 <body>
   <div class="app dda-app">
@@ -32,53 +32,60 @@
     <div id="dda-error" class="alert alert-error hidden"></div>
     <div id="dda-success" class="alert alert-success hidden"></div>
 
-    <!-- Tab: Image Library — reads from library_sources/ year folders -->
+    <!-- Tab: Image Library — zone/folder/year hierarchy under library_sources/ -->
     <section id="tab-library" class="dda-panel active" role="tabpanel">
       <div class="dda-layout">
         <aside class="dda-sidebar card">
           <div class="card-header">
-            <h3>Years</h3>
-            <button type="button" class="btn btn-secondary btn-sm" id="btn-refresh-lib" title="Rescan folder">Refresh</button>
+            <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>
           </div>
           <div id="lib-folder-path" class="dda-folder-path dim"></div>
-          <input type="search" id="lib-tree-search" class="dda-search" placeholder="Filter years…" />
+          <input type="search" id="lib-tree-search" class="dda-search" placeholder="Filter zones, folders, 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>Local folder library</h3>
+              <h3>Folder library</h3>
               <span class="dim" id="lib-config-hint"></span>
             </div>
             <p class="sub" id="lib-instructions">
-              Copy <code>.tif</code> images into <code>library_sources/YEAR/</code> in your project folder, then click <strong>Refresh</strong>.
+              Organize images as <code>library_sources/{zone}/{folder}/{year}/</code>, then click <strong>Refresh</strong>.
             </p>
             <pre id="lib-path-display" class="dda-path-code"></pre>
           </div>
-          <div class="card hidden" id="hf-upload-card">
+          <div class="card" id="upload-card">
             <div class="card-header">
-              <h3>Upload to Space storage</h3>
-              <span class="dim">Required on Hugging Face</span>
+              <h3 id="upload-card-title">Upload to library</h3>
+              <span class="dim" id="upload-card-hint"></span>
             </div>
-            <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>
+            <p class="sub" id="hf-upload-limit">Select zone, folder, and year before uploading.</p>
             <form id="form-hf-upload" class="dda-upload-form">
               <div class="location-row">
                 <div class="form-group">
-                  <label for="hf-year">Year folder</label>
-                  <input type="number" id="hf-year" required min="2000" max="2100" value="2025" />
+                  <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" />
                 </div>
                 <div class="form-group">
                   <label for="hf-file">GeoTIFF file</label>
-                  <input type="file" id="hf-file" accept=".tif,.tiff" required />
+                  <input type="file" id="hf-file" accept=".tif,.tiff,.png,.jpg,.jpeg" required />
                 </div>
               </div>
-              <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 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>
               <button type="submit" class="btn btn-primary" id="btn-hf-upload">Upload to library</button>
             </form>
@@ -88,7 +95,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 year or add images to library_sources/.</p></div>
+            <div id="lib-grid" class="dda-grid"><p class="dim">Select a zone, folder, or year in the sidebar.</p></div>
           </div>
         </main>
       </div>
@@ -259,8 +266,76 @@
     </div>
   </div>
 
-  <script src="/static/js/dda/app.js?v=12"></script>
-  <script src="/static/js/dda/library.js?v=6"></script>
+  <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/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>