Implement unlimited-depth tree library architecture for dev DDA.

Replace dual year-folder and zone/village models with dda_tree_nodes, image_library, and audit_logs. Adds tree CRUD APIs, node upload, Delhi seed migration, recursive TreeView UI, and wires compare/detect to tree paths.

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

DEPLOYMENT.md

@@ -133,7 +133,8 @@ 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) |
+| `STORAGE_ROOT` | Tree library root directory (default: `data/library_sources/`) |
+| `LOCAL_LIBRARY_ROOT` | Alias for storage root override |
 | `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,13 +149,33 @@ Dev Space can omit `SECRET_KEY` (login is disabled on both Spaces).
 
 ---
 
+## Tree library layout (unlimited depth)
+
+Images are organized in a **configurable tree** (zone → area → year → image type, or any depth):
+
+```text
+library_sources/
+  central_delhi/
+    karol_bagh/
+      2025/
+        Images/
+          satellite.tif
+```
+
+- **API:** `GET /api/dda/tree`, `POST /api/dda/tree/nodes`, upload via `POST /api/dda/tree/nodes/{id}/images/upload`
+- **UI:** Recursive tree sidebar, **Manage** (admin) for create/rename/move/delete
+- **Storage:** Slug-based disk paths; display names in `node_path`
+- **Legacy:** Flat `library_sources/YEAR/` files auto-migrate to `Unassigned/Legacy/{year}/Images/` on startup
+
+---
+
 ## 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)
+2. **Tree library** — Create zone → area → year nodes (admin); upload GeoTIFF to node; tree + grid show breadcrumb
+3. **Compare** — Select T1/T2 from tree library; Run Detection completes
 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)

app/dda/admin_routes.py

@@ -12,7 +12,7 @@ from ..database import DATA_DIR, get_db
 from ..models import DetectionRun, User
 from .dda_auth import current_dda_user, get_user_role, require_min_role
 from .job_runner import is_job_runner_busy, reconcile_stale_jobs
-from .local_library import scan_images
+from .tree.image_service import list_all_images
 from .models import DetectionJob, RegionReview
 
 logger = logging.getLogger(__name__)
@@ -43,7 +43,7 @@ def admin_status(
     disk = shutil.disk_usage(DATA_DIR)
     return {
         "role": get_user_role(db, user),
-        "libraryImages": len(scan_images()),
+        "libraryImages": len(list_all_images(db)),
         "detectionRuns": runs,
         "jobsQueued": jobs_queued,
         "jobsRunning": jobs_running,

app/dda/bootstrap.py

@@ -4,7 +4,7 @@ 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, get_storage_root, is_hf_hosted
 from .admin_routes import router as admin_router
 from .jobs_routes import router as jobs_router
 from .library_routes import router as library_router
@@ -12,7 +12,7 @@ from .local_routes import router as local_router
 from .reports_routes import router as reports_router
 from .review_routes import router as review_router
 from .training_routes import router as training_router
-from .seed import seed_delhi_hierarchy
+from .tree.routes import router as tree_router
 from .dda_auth import seed_dda_admin
 
 logger = logging.getLogger(__name__)
@@ -23,7 +23,7 @@ def init_dda_database():
     if not IS_DDA_MODE:
         return
     ensure_library_dirs()
-    ensure_local_year_folders()
+    get_storage_root().mkdir(parents=True, exist_ok=True)
     try:
         with engine.connect() as conn:
             for stmt in (
@@ -46,33 +46,51 @@ def init_dda_database():
     except Exception as exc:
         logger.warning("DDA schema migration skipped: %s", exc)
 
-    from ..database import SessionLocal
+    from ..database import Base, SessionLocal
+    from .tree.models import AuditLog, ImageLibrary, TreeNode  # noqa: F401
+    try:
+        Base.metadata.create_all(bind=engine, tables=[
+            TreeNode.__table__,
+            ImageLibrary.__table__,
+            AuditLog.__table__,
+        ])
+    except Exception as exc:
+        logger.warning("Tree table create skipped: %s", exc)
+
     db = SessionLocal()
     try:
-        seed_delhi_hierarchy(db)
         seed_dda_admin(db)
+        from .tree.migration import run_tree_migration
+        mig = run_tree_migration(db)
+        logger.info("Tree migration: %s", mig)
         from .job_runner import reconcile_stale_jobs
         reconcile_stale_jobs(db)
     finally:
         db.close()
 
     try:
-        from .local_library import library_debug_info, scan_images
-        info = library_debug_info()
+        from .tree.image_service import list_all_images
+        from ..database import SessionLocal as SL
+        sdb = SL()
+        try:
+            total = len(list_all_images(sdb))
+        finally:
+            sdb.close()
         logger.info(
-            "DDA library ready (hosted=%s): %d images, writable=%s",
+            "DDA tree library ready (hosted=%s): %d images, storage=%s",
             is_hf_hosted(),
-            len(scan_images()),
-            info.get("roots", [{}])[0].get("path") if info.get("roots") else "?",
+            total,
+            get_storage_root(),
         )
     except Exception as exc:
-        logger.warning("Library scan at startup failed: %s", exc)
+        logger.warning("Tree library scan at startup failed: %s", exc)
 
 
 def setup_dda(app: FastAPI) -> None:
     if not IS_DDA_MODE:
         logger.info("APP_MODE=legacy — DDA routes disabled")
         return
+    app.include_router(tree_router, prefix="/api/dda", tags=["dda-tree"])
     app.include_router(library_router, prefix="/api/dda", tags=["dda"])
     app.include_router(jobs_router, prefix="/api/dda", tags=["dda-jobs"])
     app.include_router(reports_router, prefix="/api/dda", tags=["dda-reports"])
@@ -80,4 +98,4 @@ def setup_dda(app: FastAPI) -> None:
     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(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 (tree, library, jobs, reports, review, training, admin, local)")

app/dda/config.py

@@ -44,12 +44,26 @@ def get_writable_library_root() -> Path:
     return (DATA_DIR / "library_sources").resolve()
 
 
+def get_storage_root() -> Path:
+    """Tree library root (doc: root_directory / STORAGE_ROOT)."""
+    explicit = os.environ.get("STORAGE_ROOT", "").strip()
+    if explicit:
+        return Path(explicit).resolve()
+    if os.environ.get("LOCAL_LIBRARY_ROOT"):
+        return Path(os.environ["LOCAL_LIBRARY_ROOT"]).resolve()
+    return get_writable_library_root()
+
+
 def get_library_roots() -> List[Path]:
-    """Folders scanned for year-based images."""
+    """Folders scanned for library images (tree storage root)."""
     roots: List[Path] = []
+    sr = get_storage_root()
+    if sr not in roots:
+        roots.append(sr)
     if os.environ.get("LOCAL_LIBRARY_ROOT"):
-        roots.append(Path(os.environ["LOCAL_LIBRARY_ROOT"]).resolve())
-    # Writable data dir first on Hugging Face (where uploads land)
+        p = Path(os.environ["LOCAL_LIBRARY_ROOT"]).resolve()
+        if p not in roots:
+            roots.append(p)
     if is_hf_hosted():
         wr = get_writable_library_root()
         if wr not in roots:

app/dda/job_runner.py

@@ -17,7 +17,7 @@ from ..models import DetectionRun
 from .config import get_detection_max_side
 from .detect_service import run_detection_and_save
 from .geotiff_io import load_rgb_pil
-from .local_library import safe_resolve
+from .local_routes import safe_resolve
 from .models import DetectionJob
 
 logger = logging.getLogger(__name__)

app/dda/jobs_routes.py

@@ -17,7 +17,7 @@ from .job_runner import (
     is_job_runner_busy,
     job_to_dict,
 )
-from .local_library import safe_resolve
+from .local_routes import safe_resolve
 from .models import DetectionJob
 
 logger = logging.getLogger(__name__)

app/dda/library_routes.py

@@ -65,7 +65,7 @@ def _image_to_dict(asset: ImageAsset, zone_name: str = "", village_name: str = "
 @router.get("/config")
 def dda_config():
     _require_dda()
-    from .config import MAX_GEOTIFF_BYTES, MAX_IMAGE_BYTES, get_library_roots
+    from .config import MAX_GEOTIFF_BYTES, MAX_IMAGE_BYTES, get_library_roots, get_storage_root
     max_gb = MAX_GEOTIFF_BYTES / (1024 ** 3)
     return {
         "mode": "dda",
@@ -77,8 +77,9 @@ def dda_config():
         "maxImageMb": MAX_IMAGE_BYTES // (1024 * 1024),
         "geotiffEnabled": geotiff_io_available(),
         "allowedExtensions": sorted(ALLOWED_EXTENSIONS),
-        "hierarchyMode": "admin",
-        "librarySource": "local_folder",
+        "hierarchyMode": "tree",
+        "librarySource": "tree_library",
+        "storageRoot": str(get_storage_root()),
         "localLibraryPaths": [str(r) for r in get_library_roots()],
     }
 
@@ -86,34 +87,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 .tree.tree_service import build_tree
+    return {"tree": build_tree(db)}
 
 
 @router.get("/images")
@@ -195,6 +170,10 @@ async def upload_image(
     db: Session = Depends(get_db),
 ):
     _require_dda()
+    raise HTTPException(
+        status_code=410,
+        detail="Deprecated: use POST /api/dda/tree/nodes/{node_id}/images/upload",
+    )
     ensure_library_dirs()
     user = get_or_create_guest_user(db)
 

app/dda/local_routes.py

@@ -1,16 +1,16 @@
-"""API for reading images from local library_sources/ year folders."""
+"""Slim local helpers: thumb, resolve, detect — backed by tree library."""
 import logging
 from pathlib import Path
 from typing import Optional
 
-from fastapi import APIRouter, Depends, File, Form, HTTPException, Query, Request, UploadFile
+from fastapi import APIRouter, Depends, Form, HTTPException, Query, Request
 from fastapi.responses import FileResponse
 from PIL import Image
 from sqlalchemy.orm import Session
 
 from ..database import get_db
 from ..models import User
-from .dda_auth import current_dda_user, require_min_role
+from .dda_auth import current_dda_user
 from .detect_service import run_detection_and_save
 from .geotiff_io import load_rgb_pil
 
@@ -20,19 +20,12 @@ from .config import (
     geotiff_io_available,
     get_detection_max_side,
     get_library_roots,
-    get_writable_library_root,
+    get_storage_root,
     is_hf_hosted,
-    max_upload_bytes_for_extension,
 )
-from .local_library import (
-    entry_to_dict,
-    get_or_build_thumb,
-    library_debug_info,
-    safe_resolve,
-    scan_images,
-    scan_years,
-)
-from .upload_io import stream_upload_to_file
+from .tree.image_service import get_or_build_thumb, list_all_images
+from .tree.path_service import resolve_file
+from .tree.tree_service import build_tree
 
 logger = logging.getLogger(__name__)
 router = APIRouter()
@@ -46,37 +39,35 @@ def _require_dda():
         )
 
 
-def _safe_basename(filename: str) -> str:
-    name = Path(filename or "upload").name
-    if not name or name in (".", ".."):
-        raise HTTPException(status_code=400, detail="Invalid filename")
-    return name
+def safe_resolve(relative_path: str) -> Path:
+    try:
+        return resolve_file(relative_path)
+    except FileNotFoundError:
+        raise HTTPException(status_code=404, detail="Image file not found")
+    except ValueError as exc:
+        raise HTTPException(status_code=400, detail=str(exc))
 
 
 @router.get("/local/config")
 def local_library_config():
     _require_dda()
-    roots = [str(r) for r in get_library_roots()]
-    writable = str(get_writable_library_root())
+    storage = str(get_storage_root())
     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."
-        )
-    else:
-        instructions = (
-            "Copy .tif images into library_sources/YEAR/ in your project folder, then Refresh. "
-            "Or use Upload to save into data/library_sources/."
-        )
+    instructions = (
+        "Select a node in the tree, choose image type, and upload. "
+        "Files are stored under {zone}/{area}/…/Images/ in persistent storage."
+        if hosted
+        else "Use the tree library to organize images by zone/area/year, or upload via the form."
+    )
     return {
-        "source": "local_folder",
+        "source": "tree_library",
         "isHosted": hosted,
         "spaceId": __import__("os").environ.get("SPACE_ID", ""),
         "appMode": "dda" if IS_DDA_MODE else "legacy",
-        "rootPath": roots[0] if roots else "",
-        "rootPaths": roots,
-        "writablePath": writable,
+        "rootPath": storage,
+        "rootPaths": [str(r) for r in get_library_roots()],
+        "writablePath": storage,
+        "storageRoot": storage,
         "instructions": instructions,
         "geotiffEnabled": geotiff_io_available(),
         "detectionMaxSide": get_detection_max_side(),
@@ -86,40 +77,14 @@ def local_library_config():
     }
 
 
-@router.get("/local/debug")
-def local_debug():
-    _require_dda()
-    return library_debug_info()
-
-
-@router.get("/local/years")
-def local_years():
-    _require_dda()
-    return {"years": scan_years(), "rootPaths": [str(r) for r in get_library_roots()]}
-
-
 @router.get("/local/images")
 def local_images(
-    year: Optional[int] = Query(None),
+    node_id: Optional[int] = Query(None),
     q: Optional[str] = Query(None),
+    db: Session = Depends(get_db),
 ):
     _require_dda()
-    entries = scan_images(year=year, query=q)
-    return [entry_to_dict(e) for e in entries]
-
-
-@router.get("/local/images/detail")
-def local_image_detail(path: str = Query(..., description="Relative path e.g. 2025/aerial.tif")):
-    _require_dda()
-    entries = scan_images()
-    norm = path.replace("\\", "/")
-    match = next((e for e in entries if e.path == norm), None)
-    if not match:
-        safe_resolve(path)
-        match = next((e for e in scan_images() 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)
+    return list_all_images(db, node_id=node_id, query=q)
 
 
 @router.get("/local/thumb")
@@ -128,8 +93,6 @@ def local_thumb(path: str = Query(...)):
     try:
         thumb = get_or_build_thumb(path)
         return FileResponse(thumb, media_type="image/png")
-    except HTTPException:
-        raise
     except Exception as exc:
         logger.warning("Thumb endpoint fallback for %s: %s", path, exc)
         from .config import LOCAL_THUMB_CACHE
@@ -140,66 +103,16 @@ def local_thumb(path: str = Query(...)):
         return FileResponse(cache, media_type="image/png")
 
 
-@router.post("/local/upload")
-async def local_upload(
-    request: Request,
-    file: UploadFile = File(...),
-    year: int = Form(...),
-    db: Session = Depends(get_db),
-    user: User = Depends(current_dda_user),
-):
-    """Upload GeoTIFF into persistent library_sources/YEAR/ (required on HF)."""
-    _require_dda()
-    require_min_role(user, db, "uploader")
-    if year < 1990 or year > 2100:
-        raise HTTPException(status_code=400, detail="year must be between 1990 and 2100")
-
-    original = _safe_basename(file.filename or "upload")
-    ext = Path(original).suffix.lower()
-    from .config import ALLOWED_EXTENSIONS
-    if ext not in ALLOWED_EXTENSIONS:
-        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
-
-    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)
-    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}",
-        "fileSizeBytes": size,
-        "writablePath": str(dest),
-    }
-
-
 @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()
-    logger.info("Library rescan: %d images, roots=%s", total, info.get("roots"))
+    tree = build_tree(db)
+    images = list_all_images(db)
     return {
         "ok": True,
-        "years": years,
-        "totalImages": total,
-        "rootPaths": [str(r) for r in get_library_roots()],
-        "writablePath": str(get_writable_library_root()),
-        "debug": info,
+        "tree": tree,
+        "totalImages": len(images),
+        "storageRoot": str(get_storage_root()),
     }
 
 
@@ -220,7 +133,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,12 +158,9 @@ 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)
 
-    max_side = get_detection_max_side()
-
     if title == "Untitled run":
         title = f"{Path(base_norm).name} vs {Path(comp_norm).name}"
 
@@ -268,7 +178,7 @@ async def detect_from_library(
             detection_sensitivity=detection_sensitivity,
             min_region_area=min_region_area,
             notify_email=notify_email,
-            max_size=max_side,
+            max_size=get_detection_max_side(),
             geo_bounds_path=base_file,
             user_id=user.id,
         )

app/dda/tree/__init__.py

@@ -0,0 +1 @@
+"""Unlimited-depth tree library for DDA (dev)."""

app/dda/tree/audit_service.py

@@ -0,0 +1,28 @@
+"""Audit logging for tree mutations."""
+from __future__ import annotations
+
+import json
+from typing import Any, Optional
+
+from sqlalchemy.orm import Session
+
+from .models import AuditLog
+
+
+def log_action(
+    db: Session,
+    action: str,
+    *,
+    node_id: Optional[int] = None,
+    old_value: Any = None,
+    new_value: Any = None,
+    action_by: str = "",
+) -> None:
+    entry = AuditLog(
+        action=action,
+        node_id=node_id,
+        old_value=json.dumps(old_value, default=str) if old_value is not None else "",
+        new_value=json.dumps(new_value, default=str) if new_value is not None else "",
+        action_by=action_by or "",
+    )
+    db.add(entry)

app/dda/tree/image_service.py

@@ -0,0 +1,160 @@
+"""Image upload and listing for tree nodes."""
+from __future__ import annotations
+
+import hashlib
+import logging
+from datetime import date, datetime
+from pathlib import Path
+from typing import List, Optional
+from urllib.parse import quote
+
+from fastapi import HTTPException, UploadFile
+from sqlalchemy.orm import Session
+
+from ..config import ALLOWED_EXTENSIONS, LOCAL_THUMB_CACHE, max_upload_bytes_for_extension
+from ..geotiff_io import bounds_to_json, inspect_image, raster_to_preview_png, write_placeholder_png
+from ..upload_io import stream_upload_to_file
+from .audit_service import log_action
+from .models import ImageLibrary, TreeNode
+from .path_service import images_dir, resolve_file, storage_root
+from .tree_service import get_node_or_404
+
+logger = logging.getLogger(__name__)
+
+IMAGE_TYPES = {"Satellite", "Drone", "Orthomosaic", "DEM", "GeoTIFF", "Raster", "PNG", "JPEG"}
+
+
+def _safe_basename(filename: str) -> str:
+    name = Path(filename or "upload").name
+    if not name or name in (".", ".."):
+        raise HTTPException(status_code=400, detail="Invalid filename")
+    return name
+
+
+def _thumb_cache_path(relative_path: str) -> Path:
+    key = hashlib.sha256(relative_path.encode("utf-8")).hexdigest()[:32]
+    return LOCAL_THUMB_CACHE / f"{key}.png"
+
+
+def image_to_dict(img: ImageLibrary, node: Optional[TreeNode] = None) -> dict:
+    encoded = quote(img.file_path, safe="/")
+    return {
+        "id": img.id,
+        "nodeId": img.node_id,
+        "path": img.file_path,
+        "filename": img.image_name,
+        "imageName": img.image_name,
+        "imageType": img.image_type,
+        "nodePath": node.node_path if node else "",
+        "breadcrumb": f"{node.node_path}/{img.image_name}" if node else img.image_name,
+        "fileSizeBytes": img.file_size_bytes,
+        "captureDate": img.capture_date.isoformat() if img.capture_date else None,
+        "uploadedBy": img.uploaded_by,
+        "uploadedOn": img.uploaded_on.isoformat() if img.uploaded_on else None,
+        "thumbUrl": f"/api/dda/local/thumb?path={encoded}",
+        "hasGeoref": img.has_georef,
+        "width": img.width,
+        "height": img.height,
+        "format": img.format,
+        "source": "tree_library",
+    }
+
+
+async def upload_image(
+    db: Session,
+    node_id: int,
+    file: UploadFile,
+    *,
+    image_type: str,
+    capture_date: Optional[str],
+    uploaded_by: str,
+) -> ImageLibrary:
+    node = get_node_or_404(db, node_id)
+    itype = image_type.strip() or "GeoTIFF"
+    if itype not in IMAGE_TYPES:
+        raise HTTPException(status_code=400, detail=f"image_type must be one of: {', '.join(sorted(IMAGE_TYPES))}")
+
+    original = _safe_basename(file.filename or "upload")
+    ext = Path(original).suffix.lower()
+    if ext not in ALLOWED_EXTENSIONS:
+        raise HTTPException(status_code=400, detail=f"Allowed extensions: {', '.join(sorted(ALLOWED_EXTENSIONS))}")
+
+    dest_dir = images_dir(node.physical_path)
+    dest_dir.mkdir(parents=True, exist_ok=True)
+    dest = dest_dir / original
+    if dest.exists():
+        stem, suffix = Path(original).stem, Path(original).suffix
+        n = 1
+        while dest.exists():
+            dest = dest_dir / f"{stem}_{n}{suffix}"
+            n += 1
+
+    size = await stream_upload_to_file(file, dest, max_upload_bytes_for_extension(ext))
+    rel = dest.relative_to(storage_root()).as_posix()
+
+    cap = None
+    if capture_date:
+        try:
+            cap = datetime.fromisoformat(capture_date.strip())
+        except ValueError:
+            try:
+                cap = datetime.combine(date.fromisoformat(capture_date.strip()), datetime.min.time())
+            except ValueError:
+                raise HTTPException(status_code=400, detail="capture_date must be YYYY-MM-DD")
+
+    meta = inspect_image(dest)
+    img = ImageLibrary(
+        node_id=node.id,
+        image_name=dest.name,
+        image_type=itype,
+        file_path=rel,
+        capture_date=cap,
+        uploaded_by=uploaded_by or "",
+        file_size_bytes=size,
+        thumb_cache_key=hashlib.sha256(rel.encode()).hexdigest()[:32],
+        width=meta.width,
+        height=meta.height,
+        has_georef=meta.has_georef,
+        bounds_json=bounds_to_json(meta.bounds_wgs84) or "",
+        format=meta.format,
+    )
+    db.add(img)
+    log_action(db, "upload", node_id=node.id, new_value={"file": rel, "type": itype}, action_by=uploaded_by)
+    db.commit()
+    db.refresh(img)
+    logger.info("Uploaded %s -> %s", original, rel)
+    return img
+
+
+def list_images_for_node(db: Session, node_id: int) -> List[dict]:
+    node = get_node_or_404(db, node_id)
+    rows = db.query(ImageLibrary).filter(ImageLibrary.node_id == node_id).order_by(ImageLibrary.uploaded_on.desc()).all()
+    return [image_to_dict(r, node) for r in rows]
+
+
+def list_all_images(db: Session, *, node_id: Optional[int] = None, query: Optional[str] = None) -> List[dict]:
+    q = db.query(ImageLibrary, TreeNode).join(TreeNode, ImageLibrary.node_id == TreeNode.id).filter(TreeNode.is_active == True)  # noqa: E712
+    if node_id:
+        q = q.filter(ImageLibrary.node_id == node_id)
+    if query:
+        like = f"%{query.strip().lower()}%"
+        q = q.filter(
+            (ImageLibrary.image_name.ilike(like)) | (TreeNode.node_path.ilike(like))
+        )
+    q = q.order_by(ImageLibrary.uploaded_on.desc())
+    return [image_to_dict(img, node) for img, node in q.all()]
+
+
+def get_or_build_thumb(relative_path: str, max_side: int = 256) -> Path:
+    full = resolve_file(relative_path)
+    cache = _thumb_cache_path(relative_path)
+    try:
+        if cache.exists() and cache.stat().st_mtime >= full.stat().st_mtime:
+            return cache
+        cache.parent.mkdir(parents=True, exist_ok=True)
+        raster_to_preview_png(full, cache, max_side=max_side)
+        return cache
+    except Exception as exc:
+        logger.warning("Thumb failed for %s: %s", relative_path, exc)
+        write_placeholder_png(cache, Path(relative_path).name, max_side)
+        return cache

app/dda/tree/migration.py

@@ -0,0 +1,114 @@
+"""One-time migration: Delhi seed + flat year folders -> tree."""
+from __future__ import annotations
+
+import logging
+import shutil
+from pathlib import Path
+from typing import Optional
+
+from sqlalchemy.orm import Session
+
+from ..config import ALLOWED_EXTENSIONS, get_library_roots, get_storage_root
+from ..seed_data import DELHI_ZONES
+from .models import ImageLibrary, TreeNode
+from .path_service import ensure_node_directory, storage_root
+from .path_slugs import unique_slug
+from .tree_service import create_node
+
+logger = logging.getLogger(__name__)
+
+LEGACY_ZONE = "Unassigned"
+LEGACY_AREA = "Legacy"
+
+
+def _is_year_dir(name: str) -> bool:
+    return len(name) == 4 and name.isdigit() and 1990 <= int(name) <= 2100
+
+
+def seed_delhi_tree(db: Session) -> dict:
+    if db.query(TreeNode).count() > 0:
+        return {"seeded": False, "nodes": db.query(TreeNode).count()}
+
+    zones_created = 0
+    areas_created = 0
+    for zone_name, areas in DELHI_ZONES.items():
+        zone = create_node(db, parent_id=None, node_name=zone_name, node_type="Zone", created_by="system")
+        zones_created += 1
+        for area_name in areas:
+            create_node(db, parent_id=zone.id, node_name=area_name, node_type="Area", created_by="system")
+            areas_created += 1
+
+    return {"seeded": True, "zones": zones_created, "areas": areas_created}
+
+
+def _find_or_create_legacy_branch(db: Session) -> TreeNode:
+    zone = db.query(TreeNode).filter(TreeNode.parent_id == None, TreeNode.node_name == LEGACY_ZONE).first()  # noqa: E711
+    if not zone:
+        zone = create_node(db, parent_id=None, node_name=LEGACY_ZONE, node_type="Zone", created_by="system")
+    area = db.query(TreeNode).filter(TreeNode.parent_id == zone.id, TreeNode.node_name == LEGACY_AREA).first()
+    if not area:
+        area = create_node(db, parent_id=zone.id, node_name=LEGACY_AREA, node_type="Area", created_by="system")
+    return area
+
+
+def _find_or_create_year_node(db: Session, parent: TreeNode, year: str) -> TreeNode:
+    existing = db.query(TreeNode).filter(TreeNode.parent_id == parent.id, TreeNode.node_name == year).first()
+    if existing:
+        return existing
+    return create_node(db, parent_id=parent.id, node_name=year, node_type="Year", created_by="system")
+
+
+def migrate_flat_year_folders(db: Session) -> dict:
+    moved = 0
+    indexed = 0
+    legacy_area = _find_or_create_legacy_branch(db)
+    root = get_storage_root()
+
+    for lib_root in get_library_roots():
+        if not lib_root.exists() or lib_root.resolve() != root.resolve():
+            continue
+        for entry in sorted(lib_root.iterdir()):
+            if not entry.is_dir() or not _is_year_dir(entry.name):
+                continue
+            year_node = _find_or_create_year_node(db, legacy_area, entry.name)
+            dest_images = ensure_node_directory(year_node.physical_path) / "Images"
+            for path in sorted(entry.iterdir()):
+                if not path.is_file() or path.suffix.lower() not in ALLOWED_EXTENSIONS:
+                    continue
+                target = dest_images / path.name
+                if target.exists():
+                    stem, suffix = path.stem, path.suffix
+                    n = 1
+                    while target.exists():
+                        target = dest_images / f"{stem}_{n}{suffix}"
+                        n += 1
+                if path.resolve() != target.resolve():
+                    shutil.move(str(path), str(target))
+                rel = target.relative_to(root).as_posix()
+                if not db.query(ImageLibrary).filter(ImageLibrary.file_path == rel).first():
+                    db.add(ImageLibrary(
+                        node_id=year_node.id,
+                        image_name=target.name,
+                        image_type="GeoTIFF",
+                        file_path=rel,
+                        uploaded_by="migration",
+                        file_size_bytes=target.stat().st_size,
+                    ))
+                    indexed += 1
+                moved += 1
+            try:
+                if entry.is_dir() and not any(entry.iterdir()):
+                    entry.rmdir()
+            except OSError:
+                pass
+
+    if moved or indexed:
+        db.commit()
+        logger.info("Tree migration: moved=%d indexed=%d", moved, indexed)
+    return {"moved": moved, "indexed": indexed}
+
+
+def run_tree_migration(db: Session) -> dict:
+    seed_result = seed_delhi_tree(db)
+    migrate_result = migrate_flat_year_folders(db)
+    return {"seed": seed_result, "migrate": migrate_result}

app/dda/tree/models.py

@@ -0,0 +1,64 @@
+"""SQLAlchemy models for unlimited-depth tree library."""
+from datetime import datetime, timezone
+
+from sqlalchemy import Boolean, Column, DateTime, ForeignKey, Integer, String, Text
+from sqlalchemy.orm import relationship
+
+from ...database import Base
+
+
+def _utcnow():
+    return datetime.now(timezone.utc)
+
+
+class TreeNode(Base):
+    __tablename__ = "dda_tree_nodes"
+
+    id = Column(Integer, primary_key=True, index=True)
+    parent_id = Column(Integer, ForeignKey("dda_tree_nodes.id"), nullable=True, index=True)
+    node_name = Column(String(500), nullable=False)
+    node_type = Column(String(100), default="Folder")
+    node_level = Column(Integer, default=0)
+    node_path = Column(Text, default="")  # display path: North Zone/Area A/2025
+    slug = Column(String(64), nullable=False, index=True)
+    physical_path = Column(Text, default="")  # relative slug path from storage root
+    created_by = Column(String(100), default="")
+    created_at = Column(DateTime, default=_utcnow)
+    is_active = Column(Boolean, default=True, index=True)
+
+    parent = relationship("TreeNode", remote_side=[id], backref="children")
+    images = relationship("ImageLibrary", back_populates="node", cascade="all, delete-orphan")
+
+
+class ImageLibrary(Base):
+    __tablename__ = "dda_image_library"
+
+    id = Column(Integer, primary_key=True, index=True)
+    node_id = Column(Integer, ForeignKey("dda_tree_nodes.id"), nullable=False, index=True)
+    image_name = Column(String(500), nullable=False)
+    image_type = Column(String(100), default="GeoTIFF")
+    file_path = Column(Text, nullable=False, unique=True)  # relative to storage root
+    capture_date = Column(DateTime, nullable=True)
+    uploaded_by = Column(String(100), default="")
+    uploaded_on = Column(DateTime, default=_utcnow)
+    file_size_bytes = Column(Integer, default=0)
+    thumb_cache_key = Column(String(64), default="")
+    width = Column(Integer, default=0)
+    height = Column(Integer, default=0)
+    has_georef = Column(Boolean, default=False)
+    bounds_json = Column(Text, default="")
+    format = Column(String(32), default="")
+
+    node = relationship("TreeNode", back_populates="images")
+
+
+class AuditLog(Base):
+    __tablename__ = "dda_audit_logs"
+
+    id = Column(Integer, primary_key=True, index=True)
+    action = Column(String(100), nullable=False)
+    node_id = Column(Integer, ForeignKey("dda_tree_nodes.id"), nullable=True, index=True)
+    old_value = Column(Text, default="")
+    new_value = Column(Text, default="")
+    action_date = Column(DateTime, default=_utcnow)
+    action_by = Column(String(100), default="")

app/dda/tree/path_service.py

@@ -0,0 +1,66 @@
+"""Physical directory sync for tree nodes."""
+from __future__ import annotations
+
+import logging
+import shutil
+from pathlib import Path
+
+from ..config import get_storage_root
+
+logger = logging.getLogger(__name__)
+
+
+def storage_root() -> Path:
+    root = get_storage_root()
+    root.mkdir(parents=True, exist_ok=True)
+    return root
+
+
+def absolute_path(relative_physical_path: str) -> Path:
+    rel = (relative_physical_path or "").replace("\\", "/").strip("/")
+    return storage_root() / rel if rel else storage_root()
+
+
+def images_dir(relative_physical_path: str) -> Path:
+    return absolute_path(relative_physical_path) / "Images"
+
+
+def ensure_node_directory(relative_physical_path: str) -> Path:
+    path = absolute_path(relative_physical_path)
+    path.mkdir(parents=True, exist_ok=True)
+    (path / "Images").mkdir(parents=True, exist_ok=True)
+    return path
+
+
+def move_directory(old_rel: str, new_rel: str) -> None:
+    old_abs = absolute_path(old_rel)
+    new_abs = absolute_path(new_rel)
+    if not old_abs.exists():
+        ensure_node_directory(new_rel)
+        return
+    new_abs.parent.mkdir(parents=True, exist_ok=True)
+    if new_abs.exists():
+        raise OSError(f"Destination already exists: {new_rel}")
+    shutil.move(str(old_abs), str(new_abs))
+    logger.info("Moved tree folder %s -> %s", old_rel, new_rel)
+
+
+def delete_directory(relative_physical_path: str) -> None:
+    path = absolute_path(relative_physical_path)
+    if path.exists() and path.is_dir():
+        shutil.rmtree(path)
+        logger.info("Deleted tree folder %s", relative_physical_path)
+
+
+def resolve_file(relative_file_path: str) -> Path:
+    rel = relative_file_path.replace("\\", "/").lstrip("/")
+    if not rel or ".." in rel.split("/"):
+        raise ValueError("Invalid file path")
+    full = (storage_root() / rel).resolve()
+    try:
+        full.relative_to(storage_root().resolve())
+    except ValueError as exc:
+        raise ValueError("Path escapes storage root") from exc
+    if not full.is_file():
+        raise FileNotFoundError(relative_file_path)
+    return full

app/dda/tree/path_slugs.py

@@ -0,0 +1,32 @@
+"""Filesystem-safe slugs for tree node paths."""
+from __future__ import annotations
+
+import re
+import unicodedata
+from typing import Set
+
+RESERVED = frozenset({"images", "thumbs", "cache", "legacy"})
+
+
+def slugify(name: str, *, fallback: str = "node") -> str:
+    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:
+        text = f"{text}_1"
+    return text[:64]
+
+
+def unique_slug(base: str, existing: Set[str]) -> str:
+    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

app/dda/tree/routes.py

@@ -0,0 +1,172 @@
+"""FastAPI routes for unlimited-depth tree library."""
+from __future__ import annotations
+
+from typing import Optional
+
+from fastapi import APIRouter, Depends, File, Form, HTTPException, UploadFile
+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
+from ..dda_auth import current_dda_user, get_user_role, require_min_role
+from .image_service import IMAGE_TYPES, image_to_dict, list_all_images, list_images_for_node, upload_image
+from .tree_service import build_tree, create_node, delete_node, get_node_or_404, move_node, rename_node
+
+router = APIRouter()
+
+
+def _require_dda():
+    if not IS_DDA_MODE:
+        raise HTTPException(status_code=404, detail="DDA mode is not enabled")
+
+
+class NodeCreateBody(BaseModel):
+    parent_id: Optional[int] = None
+    node_name: str = Field(..., min_length=1, max_length=500)
+    node_type: str = Field(default="Folder", max_length=100)
+
+
+class NodeRenameBody(BaseModel):
+    node_name: str = Field(..., min_length=1, max_length=500)
+    rename_physical: bool = False
+
+
+class NodeMoveBody(BaseModel):
+    parent_id: Optional[int] = None
+
+
+class NodeDeleteBody(BaseModel):
+    delete_files: bool = False
+
+
+@router.get("/me")
+def tree_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("/tree")
+def get_tree(db: Session = Depends(get_db), user: User = Depends(current_dda_user)):
+    _require_dda()
+    return {"tree": build_tree(db), "imageTypes": sorted(IMAGE_TYPES)}
+
+
+@router.post("/tree/nodes")
+def api_create_node(
+    body: NodeCreateBody,
+    db: Session = Depends(get_db),
+    user: User = Depends(current_dda_user),
+):
+    _require_dda()
+    require_min_role(user, db, "admin")
+    node = create_node(
+        db,
+        parent_id=body.parent_id,
+        node_name=body.node_name,
+        node_type=body.node_type,
+        created_by=user.email or str(user.id),
+    )
+    return {"status": True, "message": "Node Created Successfully", "node": {
+        "id": node.id, "name": node.node_name, "nodePath": node.node_path,
+    }}
+
+
+@router.put("/tree/nodes/{node_id}/rename")
+def api_rename_node(
+    node_id: int,
+    body: NodeRenameBody,
+    db: Session = Depends(get_db),
+    user: User = Depends(current_dda_user),
+):
+    _require_dda()
+    require_min_role(user, db, "admin")
+    node = rename_node(
+        db, node_id, body.node_name,
+        action_by=user.email or str(user.id),
+        rename_physical=body.rename_physical,
+    )
+    return {"status": True, "message": "Node Renamed Successfully", "node": {
+        "id": node.id, "name": node.node_name, "nodePath": node.node_path,
+    }}
+
+
+@router.post("/tree/nodes/{node_id}/move")
+def api_move_node(
+    node_id: int,
+    body: NodeMoveBody,
+    db: Session = Depends(get_db),
+    user: User = Depends(current_dda_user),
+):
+    _require_dda()
+    require_min_role(user, db, "admin")
+    node = move_node(db, node_id, body.parent_id, action_by=user.email or str(user.id))
+    return {"status": True, "message": "Node Moved Successfully", "node": {
+        "id": node.id, "parentId": node.parent_id, "nodePath": node.node_path,
+    }}
+
+
+@router.delete("/tree/nodes/{node_id}")
+def api_delete_node(
+    node_id: int,
+    body: NodeDeleteBody = NodeDeleteBody(),
+    db: Session = Depends(get_db),
+    user: User = Depends(current_dda_user),
+):
+    _require_dda()
+    require_min_role(user, db, "admin")
+    result = delete_node(db, node_id, delete_files=body.delete_files, action_by=user.email or str(user.id))
+    return {"status": True, "message": "Node Deleted Successfully", **result}
+
+
+@router.get("/tree/nodes/{node_id}")
+def api_get_node(node_id: int, db: Session = Depends(get_db), user: User = Depends(current_dda_user)):
+    _require_dda()
+    node = get_node_or_404(db, node_id)
+    return {
+        "id": node.id,
+        "parentId": node.parent_id,
+        "name": node.node_name,
+        "nodeType": node.node_type,
+        "nodePath": node.node_path,
+        "physicalPath": node.physical_path,
+    }
+
+
+@router.get("/tree/nodes/{node_id}/images")
+def api_list_node_images(node_id: int, db: Session = Depends(get_db), user: User = Depends(current_dda_user)):
+    _require_dda()
+    return {"images": list_images_for_node(db, node_id)}
+
+
+@router.get("/tree/images")
+def api_list_images(
+    node_id: Optional[int] = None,
+    q: Optional[str] = None,
+    db: Session = Depends(get_db),
+    user: User = Depends(current_dda_user),
+):
+    _require_dda()
+    return list_all_images(db, node_id=node_id, query=q)
+
+
+@router.post("/tree/nodes/{node_id}/images/upload")
+async def api_upload_image(
+    node_id: int,
+    file: UploadFile = File(...),
+    image_type: str = Form("GeoTIFF"),
+    capture_date: str = Form(""),
+    db: Session = Depends(get_db),
+    user: User = Depends(current_dda_user),
+):
+    _require_dda()
+    require_min_role(user, db, "uploader")
+    img = await upload_image(
+        db, node_id, file,
+        image_type=image_type,
+        capture_date=capture_date or None,
+        uploaded_by=user.email or str(user.id),
+    )
+    node = get_node_or_404(db, node_id)
+    return {"status": True, "message": "Image Uploaded Successfully", "image": image_to_dict(img, node)}

app/dda/tree/tree_service.py

@@ -0,0 +1,258 @@
+"""Tree node CRUD and recursive tree building."""
+from __future__ import annotations
+
+import logging
+from typing import List, Optional
+
+from fastapi import HTTPException
+from sqlalchemy.orm import Session
+
+from .audit_service import log_action
+from .models import ImageLibrary, TreeNode
+from .path_service import delete_directory, ensure_node_directory, move_directory
+from .path_slugs import unique_slug
+
+logger = logging.getLogger(__name__)
+
+
+def _sibling_slugs(db: Session, parent_id: Optional[int]) -> set:
+    q = db.query(TreeNode).filter(TreeNode.parent_id == parent_id, TreeNode.is_active == True)  # noqa: E712
+    return {n.slug for n in q.all() if n.slug}
+
+
+def _sibling_names(db: Session, parent_id: Optional[int], exclude_id: Optional[int] = None) -> set:
+    q = db.query(TreeNode).filter(TreeNode.parent_id == parent_id, TreeNode.is_active == True)  # noqa: E712
+    if exclude_id:
+        q = q.filter(TreeNode.id != exclude_id)
+    return {n.node_name.strip().lower() for n in q.all()}
+
+
+def _node_to_dict(node: TreeNode, *, image_count: int = 0, children: Optional[list] = None) -> dict:
+    return {
+        "id": node.id,
+        "parentId": node.parent_id,
+        "name": node.node_name,
+        "nodeName": node.node_name,
+        "nodeType": node.node_type,
+        "nodeLevel": node.node_level,
+        "nodePath": node.node_path,
+        "slug": node.slug,
+        "physicalPath": node.physical_path,
+        "imageCount": image_count,
+        "children": children or [],
+    }
+
+
+def build_tree(db: Session, parent_id: Optional[int] = None) -> List[dict]:
+    nodes = (
+        db.query(TreeNode)
+        .filter(TreeNode.parent_id == parent_id, TreeNode.is_active == True)  # noqa: E712
+        .order_by(TreeNode.node_name)
+        .all()
+    )
+    result = []
+    for node in nodes:
+        children = build_tree(db, node.id)
+        img_count = db.query(ImageLibrary).filter(ImageLibrary.node_id == node.id).count()
+        child_img = sum(c.get("imageCount", 0) for c in children)
+        result.append(_node_to_dict(node, image_count=img_count + child_img, children=children))
+    return result
+
+
+def get_node_or_404(db: Session, node_id: int) -> TreeNode:
+    node = db.query(TreeNode).filter(TreeNode.id == node_id, TreeNode.is_active == True).first()  # noqa: E712
+    if not node:
+        raise HTTPException(status_code=404, detail="Node not found")
+    return node
+
+
+def create_node(
+    db: Session,
+    *,
+    parent_id: Optional[int],
+    node_name: str,
+    node_type: str,
+    created_by: str,
+) -> TreeNode:
+    name = node_name.strip()
+    if not name:
+        raise HTTPException(status_code=400, detail="node_name is required")
+    if name.lower() in _sibling_names(db, parent_id):
+        raise HTTPException(status_code=400, detail="Duplicate node name under same parent")
+
+    parent = None
+    level = 0
+    parent_physical = ""
+    parent_display = ""
+    if parent_id is not None:
+        parent = get_node_or_404(db, parent_id)
+        level = parent.node_level + 1
+        parent_physical = parent.physical_path or ""
+        parent_display = parent.node_path or parent.node_name
+
+    slug = unique_slug(name, _sibling_slugs(db, parent_id))
+    physical_path = f"{parent_physical}/{slug}".strip("/") if parent_physical else slug
+    node_path = f"{parent_display}/{name}".strip("/") if parent_display else name
+
+    node = TreeNode(
+        parent_id=parent_id,
+        node_name=name,
+        node_type=node_type or "Folder",
+        node_level=level,
+        node_path=node_path,
+        slug=slug,
+        physical_path=physical_path,
+        created_by=created_by or "",
+    )
+    db.add(node)
+    db.flush()
+    ensure_node_directory(physical_path)
+    log_action(db, "create", node_id=node.id, new_value={"name": name, "path": node_path}, action_by=created_by)
+    db.commit()
+    db.refresh(node)
+    logger.info("Created tree node %s (%s)", node_path, physical_path)
+    return node
+
+
+def rename_node(
+    db: Session,
+    node_id: int,
+    new_name: str,
+    *,
+    action_by: str,
+    rename_physical: bool = False,
+) -> TreeNode:
+    node = get_node_or_404(db, node_id)
+    name = new_name.strip()
+    if not name:
+        raise HTTPException(status_code=400, detail="node_name is required")
+    if name.lower() in _sibling_names(db, node.parent_id, exclude_id=node_id):
+        raise HTTPException(status_code=400, detail="Duplicate node name under same parent")
+
+    old = {"name": node.node_name, "path": node.node_path}
+    node.node_name = name
+
+    if node.parent_id:
+        parent = get_node_or_404(db, node.parent_id)
+        node.node_path = f"{parent.node_path}/{name}"
+    else:
+        node.node_path = name
+
+    if rename_physical:
+        old_physical = node.physical_path
+        parent_physical = ""
+        if node.parent_id:
+            parent = get_node_or_404(db, node.parent_id)
+            parent_physical = parent.physical_path or ""
+        new_slug = unique_slug(name, _sibling_slugs(db, node.parent_id) - {node.slug})
+        new_physical = f"{parent_physical}/{new_slug}".strip("/") if parent_physical else new_slug
+        if old_physical != new_physical:
+            move_directory(old_physical, new_physical)
+            node.slug = new_slug
+            node.physical_path = new_physical
+            _update_descendant_paths(db, node)
+
+    log_action(db, "rename", node_id=node.id, old_value=old, new_value={"name": name, "path": node.node_path}, action_by=action_by)
+    db.commit()
+    db.refresh(node)
+    return node
+
+
+def _update_descendant_paths(db: Session, parent: TreeNode) -> None:
+    children = db.query(TreeNode).filter(TreeNode.parent_id == parent.id, TreeNode.is_active == True).all()  # noqa: E712
+    for child in children:
+        child.node_path = f"{parent.node_path}/{child.node_name}"
+        child.physical_path = f"{parent.physical_path}/{child.slug}".strip("/")
+        ensure_node_directory(child.physical_path)
+        _update_descendant_paths(db, child)
+
+
+def move_node(
+    db: Session,
+    node_id: int,
+    new_parent_id: Optional[int],
+    *,
+    action_by: str,
+) -> TreeNode:
+    node = get_node_or_404(db, node_id)
+    if new_parent_id == node.id:
+        raise HTTPException(status_code=400, detail="Cannot move node under itself")
+
+    if new_parent_id is not None:
+        new_parent = get_node_or_404(db, new_parent_id)
+        # prevent cycle
+        cursor = new_parent
+        while cursor.parent_id is not None:
+            if cursor.parent_id == node.id:
+                raise HTTPException(status_code=400, detail="Cannot move node under its descendant")
+            cursor = get_node_or_404(db, cursor.parent_id)
+
+        if node.node_name.lower() in _sibling_names(db, new_parent_id, exclude_id=node_id):
+            raise HTTPException(status_code=400, detail="Duplicate node name under target parent")
+
+    old = {"parentId": node.parent_id, "path": node.node_path, "physical": node.physical_path}
+    old_physical = node.physical_path
+
+    node.parent_id = new_parent_id
+    if new_parent_id is None:
+        node.node_level = 0
+        node.node_path = node.node_name
+        new_physical = node.slug
+    else:
+        new_parent = get_node_or_404(db, new_parent_id)
+        node.node_level = new_parent.node_level + 1
+        node.node_path = f"{new_parent.node_path}/{node.node_name}"
+        new_physical = f"{new_parent.physical_path}/{node.slug}".strip("/")
+
+    if old_physical != new_physical:
+        move_directory(old_physical, new_physical)
+        node.physical_path = new_physical
+        _update_descendant_paths(db, node)
+
+    log_action(db, "move", node_id=node.id, old_value=old, new_value={"parentId": new_parent_id, "path": node.node_path}, action_by=action_by)
+    db.commit()
+    db.refresh(node)
+    return node
+
+
+def _descendant_ids(db: Session, node_id: int) -> List[int]:
+    ids = [node_id]
+    children = db.query(TreeNode.id).filter(TreeNode.parent_id == node_id, TreeNode.is_active == True).all()  # noqa: E712
+    for (cid,) in children:
+        ids.extend(_descendant_ids(db, cid))
+    return ids
+
+
+def delete_node(
+    db: Session,
+    node_id: int,
+    *,
+    delete_files: bool,
+    action_by: str,
+) -> dict:
+    node = get_node_or_404(db, node_id)
+    ids = _descendant_ids(db, node_id)
+    img_count = db.query(ImageLibrary).filter(ImageLibrary.node_id.in_(ids)).count()
+    if img_count > 0 and not delete_files:
+        raise HTTPException(status_code=400, detail="Node has images; set delete_files=true to remove")
+
+    old = {"path": node.node_path, "physical": node.physical_path}
+    if delete_files:
+        for nid in reversed(ids):
+            n = db.query(TreeNode).filter(TreeNode.id == nid).first()
+            if n and n.physical_path:
+                delete_directory(n.physical_path)
+            db.query(ImageLibrary).filter(ImageLibrary.node_id == nid).delete()
+            if n:
+                n.is_active = False
+    else:
+        child_count = len(ids) - 1
+        if child_count > 0:
+            raise HTTPException(status_code=400, detail="Node has child nodes; set delete_files=true or remove children first")
+        if img_count > 0:
+            raise HTTPException(status_code=400, detail="Node has images")
+        node.is_active = False
+
+    log_action(db, "delete", node_id=node_id, old_value=old, new_value={"delete_files": delete_files}, action_by=action_by)
+    db.commit()
+    return {"ok": True, "deletedIds": ids}

app/main.py

@@ -29,6 +29,7 @@ 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.tree.models import TreeNode, ImageLibrary, AuditLog  # 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
@@ -118,9 +119,15 @@ def health():
     if IS_DDA_MODE:
         try:
             from .dda.job_runner import is_job_runner_busy
-            from .dda.local_library import scan_images
+            from .dda.tree.image_service import list_all_images
+            from .database import SessionLocal
+            _sdb = SessionLocal()
+            try:
+                lib_count = len(list_all_images(_sdb))
+            finally:
+                _sdb.close()
             payload["dda"] = {
-                "libraryImages": len(scan_images()),
+                "libraryImages": lib_count,
                 "jobRunnerBusy": is_job_runner_busy(),
             }
         except Exception as exc:

static/css/dda.css

@@ -83,6 +83,35 @@
   background: var(--bg-hover);
   color: var(--grad-start);
 }
+.dda-sidebar-actions { display: flex; gap: 0.35rem; flex-wrap: wrap; }
+.dda-tree-all, .dda-tree-node-btn {
+  display: block;
+  width: 100%;
+  text-align: left;
+  padding: 0.35rem 0.5rem;
+  margin-bottom: 0.2rem;
+  border: none;
+  background: transparent;
+  color: var(--text-muted);
+  cursor: pointer;
+  border-radius: 6px;
+  font-size: 0.88rem;
+}
+.dda-tree-all:hover, .dda-tree-all.active,
+.dda-tree-node-btn:hover, .dda-tree-node-btn.active {
+  background: var(--bg-hover);
+  color: var(--grad-start);
+}
+.dda-tree-node-wrap { margin-bottom: 0.15rem; }
+.dda-tree-node-summary { list-style: none; cursor: pointer; }
+.dda-tree-node-summary .dda-tree-node-btn { display: inline; width: auto; }
+.dda-tree-children { padding-left: 0.65rem; border-left: 1px solid var(--border); margin-left: 0.35rem; }
+.dda-tree-leaf { padding-left: 0.75rem; }
+.dda-crumb { font-size: 0.78rem; line-height: 1.3; }
+.dda-manage-panel { max-width: 540px; 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 { flex-wrap: wrap; gap: 0.4rem; margin-bottom: 0.5rem; }
 
 .dda-folder-path {
   font-size: 0.78rem;

static/js/dda/app.js

@@ -55,15 +55,16 @@ function formatBytes(n) {
 }
 
 let ddaConfig = null;
-let localYears = [];
-let selectedYear = null;
+const selectedNode = { id: null, path: '' };
 
 window.ddaState = {
   get config() { return ddaConfig; },
   get localCfg() { return window._localCfg; },
-  get years() { return localYears; },
-  get selectedYear() { return selectedYear; },
-  setYear(year) { selectedYear = year; },
+  get selectedNode() { return { ...selectedNode }; },
+  get userRole() { return window._ddaUserRole || 'analyst'; },
+  set userRole(r) { window._ddaUserRole = r; },
+  setNode(n) { selectedNode.id = n.id; selectedNode.path = n.path || ''; },
+  clearNode() { selectedNode.id = null; selectedNode.path = ''; },
   refreshImages: () => loadLibraryImages(),
   rescan: () => rescanLibrary(),
 };
@@ -83,8 +84,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);
+  if (typeof renderTree === 'function') renderTree({ tree: data.tree }, []);
+  if (typeof populateManageNodeSelect === 'function') populateManageNodeSelect();
   await loadLibraryImages();
   return data;
 }
@@ -92,125 +93,91 @@ async function rescanLibrary() {
 async function initDda() {
   hideDdaError();
   try {
+    try {
+      const me = await ddaApi('GET', '/api/dda/me');
+      window.ddaState.userRole = me.role || 'analyst';
+    } catch (_) {
+      window.ddaState.userRole = 'analyst';
+    }
+
     ddaConfig = await ddaApi('GET', '/api/dda/config');
     const localCfg = await ddaApi('GET', '/api/dda/local/config');
     window._localCfg = localCfg;
 
+    document.getElementById('btn-manage-library')?.classList.toggle('hidden', window.ddaState.userRole !== 'admin');
+
     const hint = document.getElementById('lib-config-hint');
-    if (hint) {
-      hint.textContent = localCfg.geotiffEnabled ? 'GeoTIFF ready' : 'GeoTIFF limited';
-    }
-    const paths = (localCfg.rootPaths || []).filter(Boolean);
+    if (hint) hint.textContent = localCfg.geotiffEnabled ? 'GeoTIFF ready' : 'GeoTIFF limited';
+
     const pathEl = document.getElementById('lib-path-display');
     if (pathEl) {
       pathEl.textContent = [
-        localCfg.isHosted ? 'HF writable storage:' : 'Local folders:',
-        localCfg.writablePath || paths[0] || '',
-        ...paths.filter((p) => p !== localCfg.writablePath),
+        'Storage root:',
+        localCfg.storageRoot || localCfg.writablePath || '',
+        'Layout: {zone}/{area}/…/Images/file.tif',
       ].filter(Boolean).join('\n');
     }
+
     const folderPath = document.getElementById('lib-folder-path');
     if (folderPath) {
       folderPath.textContent = localCfg.isHosted
-        ? 'Hugging Face — upload files below'
-        : (paths[0] ? `Scanning: ${paths[0]}` : '');
+        ? 'Hugging Face — tree library'
+        : `Storage: ${localCfg.storageRoot || ''}`;
     }
+
     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 resHint = document.getElementById('dda-detect-res-hint');
-    if (resHint && localCfg.detectionMaxSide) {
-      resHint.textContent = `Detection runs at up to ${localCfg.detectionMaxSide}px per side for sharper results (set DETECTION_MAX_SIDE to change).`;
-    }
-
-    const uploadLimit = document.getElementById('hf-upload-limit');
+    const uploadLimit = document.getElementById('upload-limit-hint');
     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 a tree node and image type. Max ${localCfg.maxUploadGb} GB per GeoTIFF.`;
     }
 
-    const appMode = ddaConfig.appMode || ddaConfig.mode || localCfg.appMode || 'dda';
-    if (!localCfg.isHosted && appMode !== 'dda') {
-      showDdaError('DDA mode is off. Run locally with: python run.py');
+    const resHint = document.getElementById('dda-detect-res-hint');
+    if (resHint && localCfg.detectionMaxSide) {
+      resHint.textContent = `Detection runs at up to ${localCfg.detectionMaxSide}px per side.`;
     }
 
     const urlTab = new URLSearchParams(window.location.search).get('tab');
-    if (urlTab) {
-      document.querySelector(`.dda-tab[data-tab="${urlTab}"]`)?.click();
-    }
+    if (urlTab) 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);
+    if (typeof loadTree === 'function') await loadTree();
     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() {
+  return selectedNode.path || '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 params = new URLSearchParams();
-  if (selectedYear) params.set('year', String(selectedYear));
+  if (selectedNode.id) params.set('node_id', String(selectedNode.id));
   if (q) params.set('q', q);
-  if (title) {
-    title.textContent = selectedYear ? `Images — ${selectedYear}` : 'Images — all years';
-  }
+  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 <strong>${escapeHtml(selectionTitle())}</strong>. Select a node and upload, or use Manage to create folders.</p>`;
       return;
     }
     grid.innerHTML = items.map((img) => {
-      const thumb = img.thumbUrl ? img.thumbUrl.replace(/path=[^&]+/, 'path=' + encodeURIComponent(img.path)) : '';
+      const thumb = img.thumbUrl || '';
+      const crumb = img.breadcrumb || img.nodePath || img.filename;
       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">${formatBytes(img.fileSizeBytes)}</span>
+          <span class="dim dda-crumb">${escapeHtml(crumb)}</span><br/>
+          <span class="dim">${img.imageType || ''} · ${formatBytes(img.fileSizeBytes)}</span>
         </div>
       </div>`;
     }).join('');
@@ -236,7 +203,7 @@ document.getElementById('btn-refresh-lib')?.addEventListener('click', async () =
   btn.disabled = true;
   try {
     const data = await rescanLibrary();
-    showDdaSuccess(`Library refreshed — ${data.totalImages || 0} image(s) found.`);
+    showDdaSuccess(`Library refreshed — ${data.totalImages || 0} image(s).`);
   } catch (err) {
     showDdaError(err.message);
   } finally {

static/js/dda/compare.js

@@ -49,7 +49,7 @@ function renderSlotPreview(slotKey, selection) {
   const thumb = selection.thumbUrl || thumbUrlFor(selection.path);
   wrap.innerHTML = `
     <img class="dda-slot-preview" src="${thumb}" alt="" />
-    <div class="dda-slot-meta"><strong>${selection.year}</strong> — ${selection.filename}</div>`;
+    <div class="dda-slot-meta">${escapeHtml(selection.label || selection.filename)}</div>`;
 }
 
 function populateSelects(items) {
@@ -59,7 +59,7 @@ function populateSelects(items) {
     const current = sel.value;
     const label = id === 'select-t1' ? '— Choose base image —' : '— Choose comparison image —';
     sel.innerHTML = `<option value="">${label}</option>` +
-      items.map((img) => `<option value="${encodePath(img.path)}">${img.year} — ${img.filename}</option>`).join('');
+      items.map((img) => `<option value="${encodePath(img.path)}">${escapeHtml(img.breadcrumb || img.nodePath || img.filename)}</option>`).join('');
     if (current) sel.value = current;
   });
 }
@@ -68,7 +68,7 @@ function setSlot(slotKey, img) {
   if (!img || !img.path) return;
   const item = {
     path: img.path,
-    year: img.year,
+    label: img.breadcrumb || img.nodePath || img.filename,
     filename: img.filename,
     thumbUrl: img.thumbUrl || thumbUrlFor(img.path),
   };
@@ -95,7 +95,7 @@ function findLibraryItem(path) {
   const items = ensureDdaState().libraryItems || [];
   return items.find((i) => i.path === norm) || {
     path: norm,
-    year: parseInt(norm.split('/')[0], 10) || '',
+    label: norm.split('/').pop(),
     filename: norm.split('/').pop(),
     thumbUrl: thumbUrlFor(norm),
   };
@@ -136,7 +136,7 @@ async function loadCompareLibraryGrid() {
         <div class="dda-compare-card dda-card-img${t1Sel}${t2Sel}" data-image-path="${enc}" draggable="true">
           ${thumb ? `<img src="${thumb}" alt="" loading="lazy" draggable="false" />` : '<div class="meta">No preview</div>'}
           <div class="meta">
-            <strong>${img.year}</strong><br/>
+            <span class="dim">${escapeHtml(img.breadcrumb || img.nodePath || '')}</span><br/>
             ${safeName}<br/>
             <span class="dim">${compareFormatBytes(img.fileSizeBytes)}</span>
           </div>
@@ -191,7 +191,7 @@ async function openPicker(slotKey) {
       return `
       <button type="button" class="dda-picker-item" data-path="${enc}">
         <img src="${img.thumbUrl || thumbUrlFor(img.path)}" alt="" loading="lazy" />
-        <span><strong>${img.year}</strong><br/>${img.filename}</span>
+        <span>${escapeHtml(img.breadcrumb || img.filename)}</span>
       </button>`;
     }).join('');
     list.querySelectorAll('.dda-picker-item').forEach((btn) => {

static/js/dda/library.js

@@ -1,37 +1,3 @@
-function renderYearTree(years) {
-  const tree = document.getElementById('lib-tree');
-  if (!tree) return;
-  const filter = (document.getElementById('lib-tree-search')?.value || '').toLowerCase();
-
-  const allBtn = `
-    <button type="button" class="dda-tree-year ${window.ddaState.selectedYear === null ? 'active' : ''}" data-year="">
-      All years
-    </button>`;
-
-  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('');
-
-  tree.innerHTML = allBtn + yearBtns;
-
-  tree.querySelectorAll('.dda-tree-year').forEach((btn) => {
-    btn.addEventListener('click', () => {
-      tree.querySelectorAll('.dda-tree-year').forEach((b) => b.classList.remove('active'));
-      btn.classList.add('active');
-      const raw = btn.dataset.year;
-      window.ddaState.setYear(raw ? parseInt(raw, 10) : null);
-      window.ddaState.refreshImages();
-    });
-  });
-}
-
-document.getElementById('lib-tree-search')?.addEventListener('input', () => {
-  if (window.ddaState?.years) renderYearTree(window.ddaState.years);
-});
-
 function uploadWithProgress(url, formData, onProgress) {
   return new Promise((resolve, reject) => {
     const xhr = new XMLHttpRequest();
@@ -51,53 +17,47 @@ 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) => {
+document.getElementById('form-tree-upload')?.addEventListener('submit', async (e) => {
   e.preventDefault();
   hideDdaError?.();
-  const fileInput = document.getElementById('hf-file');
+
+  const nodeId = document.getElementById('upload-node')?.value;
+  const fileInput = document.getElementById('upload-file');
   const file = fileInput?.files?.[0];
-  if (!file) {
-    showDdaError?.('Select a .tif file.');
-    return;
-  }
+  if (!nodeId) return showDdaError?.('Select a tree node.');
+  if (!file) return showDdaError?.('Select a file.');
 
   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;
+    return showDdaError?.(`File is ${formatBytes(file.size)} — max ${formatBytes(maxBytes)}.`);
   }
 
   const form = new FormData();
   form.append('file', file);
-  form.append('year', document.getElementById('hf-year').value);
+  form.append('image_type', document.getElementById('upload-image-type')?.value || 'GeoTIFF');
+  form.append('capture_date', document.getElementById('upload-capture-date')?.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');
+  const btn = document.getElementById('btn-tree-upload');
+  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) => {
+    await uploadWithProgress(`/api/dda/tree/nodes/${nodeId}/images/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)})`;
+      if (progLabel) progLabel.textContent = `Uploading… ${pct}%`;
     });
-    showDdaSuccess?.('Uploaded to Space library. Click Refresh if images do not appear.');
+    showDdaSuccess?.('Uploaded. Refreshing…');
     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.');
+    showDdaError?.(err.message || 'Upload failed.');
   } finally {
     btn.disabled = false;
     setTimeout(() => progWrap?.classList.add('hidden'), 2000);

static/js/dda/tree.js

@@ -0,0 +1,211 @@
+/** Unlimited-depth tree library UI + admin management. */
+
+let treeData = null;
+let imageTypes = [];
+
+function isAdmin() {
+  return window.ddaState?.userRole === 'admin';
+}
+
+function renderTreeNodes(nodes, depth = 0) {
+  if (!nodes || !nodes.length) return '';
+  const filter = (document.getElementById('lib-tree-search')?.value || '').toLowerCase();
+  const sel = window.ddaState?.selectedNode;
+
+  return nodes.map((node) => {
+    const name = node.name || node.nodeName;
+    const children = node.children || [];
+    const matches = !filter ||
+      name.toLowerCase().includes(filter) ||
+      (node.nodePath || '').toLowerCase().includes(filter) ||
+      children.some((c) => JSON.stringify(c).toLowerCase().includes(filter));
+
+    if (!matches && filter) return '';
+
+    const active = sel?.id === node.id;
+    const hasKids = children.length > 0;
+    const count = node.imageCount ? ` <span class="dim">(${node.imageCount})</span>` : '';
+    const indent = depth > 0 ? ` style="padding-left:${depth * 0.5}rem"` : '';
+
+    if (hasKids) {
+      return `
+        <details class="dda-tree-node-wrap" open${indent ? '' : ''}>
+          <summary class="dda-tree-node-summary ${active ? 'active' : ''}" data-node-id="${node.id}">
+            <button type="button" class="dda-tree-node-btn ${active ? 'active' : ''}" data-node-id="${node.id}"
+              data-node-path="${escapeHtml(node.nodePath || name)}">${escapeHtml(name)}${count}</button>
+          </summary>
+          <div class="dda-tree-children">${renderTreeNodes(children, depth + 1)}</div>
+        </details>`;
+    }
+    return `
+      <button type="button" class="dda-tree-node-btn dda-tree-leaf ${active ? 'active' : ''}" data-node-id="${node.id}"
+        data-node-path="${escapeHtml(node.nodePath || name)}"${indent}>${escapeHtml(name)}${count}</button>`;
+  }).join('');
+}
+
+function renderTree(tree, types) {
+  const el = document.getElementById('lib-tree');
+  if (!el) return;
+  treeData = tree;
+  if (types) imageTypes = types;
+
+  const nodes = tree?.tree || tree || [];
+  const allActive = !window.ddaState?.selectedNode?.id;
+  let html = `<button type="button" class="dda-tree-all ${allActive ? 'active' : ''}" id="btn-tree-all">All images</button>`;
+  html += renderTreeNodes(nodes);
+  if (!nodes.length) {
+    html += '<p class="dim">No nodes yet. Admins can use Manage to add zones.</p>';
+  }
+  el.innerHTML = html;
+
+  document.getElementById('btn-tree-all')?.addEventListener('click', () => {
+    window.ddaState.clearNode();
+    window.ddaState.refreshImages();
+    renderTree(treeData, imageTypes);
+    syncUploadNodeSelect();
+  });
+
+  el.querySelectorAll('.dda-tree-node-btn').forEach((btn) => {
+    btn.addEventListener('click', (e) => {
+      e.stopPropagation();
+      window.ddaState.setNode({
+        id: parseInt(btn.dataset.nodeId, 10),
+        path: btn.dataset.nodePath,
+      });
+      window.ddaState.refreshImages();
+      renderTree(treeData, imageTypes);
+      syncUploadNodeSelect();
+    });
+  });
+}
+
+document.getElementById('lib-tree-search')?.addEventListener('input', () => {
+  if (treeData) renderTree(treeData, imageTypes);
+});
+
+async function loadTree() {
+  const data = await ddaApi('GET', '/api/dda/tree');
+  renderTree(data, data.imageTypes);
+  populateNodeSelects(data.tree);
+  if (typeof populateManageNodeSelect === 'function') populateManageNodeSelect();
+  return data;
+}
+
+window.loadTree = loadTree;
+window.renderTree = renderTree;
+
+function flattenNodes(nodes, out = []) {
+  (nodes || []).forEach((n) => {
+    out.push(n);
+    flattenNodes(n.children, out);
+  });
+  return out;
+}
+
+function populateNodeSelects(tree) {
+  const flat = flattenNodes(tree || []);
+  const opts = '<option value="">— Select node —</option>' +
+    flat.map((n) => `<option value="${n.id}">${escapeHtml(n.nodePath || n.name)}</option>`).join('');
+
+  ['upload-node', 'manage-parent', 'move-parent', 'add-child-parent'].forEach((id) => {
+    const el = document.getElementById(id);
+    if (el) el.innerHTML = id === 'manage-parent' ? '<option value="">— Root —</option>' + flat.map((n) =>
+      `<option value="${n.id}">${escapeHtml(n.nodePath || n.name)}</option>`).join('') : opts;
+  });
+
+  const typeSel = document.getElementById('upload-image-type');
+  if (typeSel && imageTypes.length) {
+    typeSel.innerHTML = imageTypes.map((t) => `<option value="${t}">${t}</option>`).join('');
+  }
+  syncUploadNodeSelect();
+}
+
+function syncUploadNodeSelect() {
+  const sel = document.getElementById('upload-node');
+  const node = window.ddaState?.selectedNode;
+  if (sel && node?.id) sel.value = String(node.id);
+}
+
+/* Manage modal */
+function openManage() {
+  document.getElementById('dda-manage-modal')?.classList.remove('hidden');
+  if (treeData) populateNodeSelects(treeData.tree || treeData);
+}
+
+function closeManage() {
+  document.getElementById('dda-manage-modal')?.classList.add('hidden');
+}
+
+document.getElementById('btn-manage-library')?.addEventListener('click', openManage);
+document.getElementById('dda-manage-close')?.addEventListener('click', closeManage);
+
+document.getElementById('btn-add-node')?.addEventListener('click', async () => {
+  const parentVal = document.getElementById('add-child-parent')?.value;
+  const name = document.getElementById('add-node-name')?.value?.trim();
+  const type = document.getElementById('add-node-type')?.value || 'Folder';
+  if (!name) return showDdaError('Enter a node name.');
+  const body = { node_name: name, node_type: type, parent_id: parentVal ? parseInt(parentVal, 10) : null };
+  try {
+    await ddaApi('POST', '/api/dda/tree/nodes', { body: JSON.stringify(body) });
+    document.getElementById('add-node-name').value = '';
+    showDdaSuccess('Node created.');
+    await window.ddaState.rescan();
+  } catch (err) {
+    showDdaError(err.message);
+  }
+});
+
+document.getElementById('btn-rename-node')?.addEventListener('click', async () => {
+  const id = parseInt(document.getElementById('manage-node-select')?.value || '0', 10);
+  const name = document.getElementById('rename-node-name')?.value?.trim();
+  if (!id || !name) return showDdaError('Select a node and enter a new name.');
+  try {
+    await ddaApi('PUT', `/api/dda/tree/nodes/${id}/rename`, { body: JSON.stringify({ node_name: name }) });
+    showDdaSuccess('Node renamed.');
+    await window.ddaState.rescan();
+  } catch (err) {
+    showDdaError(err.message);
+  }
+});
+
+document.getElementById('btn-delete-node')?.addEventListener('click', async () => {
+  const id = parseInt(document.getElementById('manage-node-select')?.value || '0', 10);
+  if (!id || !confirm('Delete this node? Check delete files if removing images.')) return;
+  const deleteFiles = document.getElementById('delete-files-check')?.checked;
+  try {
+    await ddaApi('DELETE', `/api/dda/tree/nodes/${id}`, { body: JSON.stringify({ delete_files: !!deleteFiles }) });
+    showDdaSuccess('Node deleted.');
+    await window.ddaState.rescan();
+  } catch (err) {
+    showDdaError(err.message);
+  }
+});
+
+document.getElementById('btn-move-node')?.addEventListener('click', async () => {
+  const id = parseInt(document.getElementById('manage-node-select')?.value || '0', 10);
+  const parentVal = document.getElementById('move-parent')?.value;
+  if (!id) return showDdaError('Select a node to move.');
+  try {
+    await ddaApi('POST', `/api/dda/tree/nodes/${id}/move`, {
+      body: JSON.stringify({ parent_id: parentVal ? parseInt(parentVal, 10) : null }),
+    });
+    showDdaSuccess('Node moved.');
+    await window.ddaState.rescan();
+  } catch (err) {
+    showDdaError(err.message);
+  }
+});
+
+function populateManageNodeSelect() {
+  if (!treeData) return;
+  const flat = flattenNodes(treeData.tree || treeData || []);
+  const sel = document.getElementById('manage-node-select');
+  if (sel) sel.innerHTML = flat.map((n) =>
+    `<option value="${n.id}">${escapeHtml(n.nodePath || n.name)}</option>`).join('');
+}
+
+document.getElementById('dda-manage-modal')?.addEventListener('click', (e) => {
+  if (e.target.id === 'dda-manage-modal') closeManage();
+});
+
+window.populateManageNodeSelect = populateManageNodeSelect;

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=13" />
 </head>
 <body>
   <div class="app dda-app">
@@ -32,55 +32,62 @@
     <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 — unlimited-depth tree -->
     <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 tree</h3>
+            <div class="dda-sidebar-actions">
+              <button type="button" class="btn btn-secondary btn-sm hidden" id="btn-manage-library">Manage</button>
+              <button type="button" class="btn btn-secondary btn-sm" id="btn-refresh-lib">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 nodes…" />
           <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>Tree 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>.
-            </p>
+            <p class="sub" id="lib-instructions">Organize images in a configurable zone → area → year → type hierarchy.</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>Upload image</h3>
             </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>
-            <form id="form-hf-upload" class="dda-upload-form">
+            <p class="sub" id="upload-limit-hint">Select a tree node and image type.</p>
+            <form id="form-tree-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-node">Tree node</label>
+                  <select id="upload-node" required><option value="">— Select node —</option></select>
+                </div>
+                <div class="form-group">
+                  <label for="upload-image-type">Image type</label>
+                  <select id="upload-image-type">
+                    <option>GeoTIFF</option><option>Satellite</option><option>Drone</option>
+                    <option>Orthomosaic</option><option>DEM</option><option>Raster</option>
+                  </select>
                 </div>
                 <div class="form-group">
-                  <label for="hf-file">GeoTIFF file</label>
-                  <input type="file" id="hf-file" accept=".tif,.tiff" required />
+                  <label for="upload-capture-date">Capture date</label>
+                  <input type="date" id="upload-capture-date" />
+                </div>
+                <div class="form-group">
+                  <label for="upload-file">File</label>
+                  <input type="file" id="upload-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>
+              <button type="submit" class="btn btn-primary" id="btn-tree-upload">Upload to node</button>
             </form>
           </div>
           <div class="card">
@@ -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 node in the tree.</p></div>
           </div>
         </main>
       </div>
@@ -259,8 +266,45 @@
     </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">
+    <div class="dda-modal-panel card dda-manage-panel">
+      <div class="card-header">
+        <h3>Manage tree</h3>
+        <button type="button" class="btn btn-secondary btn-sm" id="dda-manage-close">Close</button>
+      </div>
+      <div class="dda-manage-section">
+        <h4>Add node</h4>
+        <div class="location-row">
+          <select id="add-child-parent"><option value="">— Root —</option></select>
+          <input type="text" id="add-node-name" placeholder="Node name" />
+          <select id="add-node-type">
+            <option>Zone</option><option>Area</option><option>Year</option>
+            <option>Satellite Images</option><option>Drone Survey</option><option>Change Detection</option>
+            <option>Folder</option>
+          </select>
+          <button type="button" class="btn btn-primary btn-sm" id="btn-add-node">Add</button>
+        </div>
+      </div>
+      <div class="dda-manage-section">
+        <h4>Edit / move / delete</h4>
+        <select id="manage-node-select"></select>
+        <div class="location-row">
+          <input type="text" id="rename-node-name" placeholder="Rename to…" />
+          <button type="button" class="btn btn-secondary btn-sm" id="btn-rename-node">Rename</button>
+        </div>
+        <div class="location-row">
+          <select id="move-parent"><option value="">— Move to root —</option></select>
+          <button type="button" class="btn btn-secondary btn-sm" id="btn-move-node">Move</button>
+        </div>
+        <label class="dda-check"><input type="checkbox" id="delete-files-check" /> Delete files on disk</label>
+        <button type="button" class="btn btn-secondary btn-sm" id="btn-delete-node">Delete node</button>
+      </div>
+    </div>
+  </div>
+
+  <script src="/static/js/dda/app.js?v=14"></script>
+  <script src="/static/js/dda/tree.js?v=1"></script>
+  <script src="/static/js/dda/library.js?v=8"></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>